U.S. patent application number 11/203225 was filed with the patent office on 2006-10-26 for methods of transforming application layer structure as objects.
Invention is credited to Dmitri Liakh, Eugene Satsuta, Luiz Scheinkman, Vitaliy Stulski, Igor Tsyganskiy.
Application Number | 20060242197 11/203225 |
Document ID | / |
Family ID | 46322449 |
Filed Date | 2006-10-26 |
United States Patent
Application |
20060242197 |
Kind Code |
A1 |
Tsyganskiy; Igor ; et
al. |
October 26, 2006 |
Methods of transforming application layer structure as objects
Abstract
Embodiments consistent with the invention transform business
application logic entities or structures into OOP structures that
represent the data, relationships, and operations of the business
application structures. The business application structures are
transformed from the application level, including consideration of
the business application logic and relationships. In one
embodiment, transformation is done using a set of automated
transformation rules. The resulting OOP structure model of the
business application structure may be used with OOP tools to
analyze, maintain, debug, modify, and revise the business
application structure, and to create new structures for the
business application.
Inventors: |
Tsyganskiy; Igor; (Los
Galos, CA) ; Stulski; Vitaliy; (San Mateo, CA)
; Liakh; Dmitri; (Foster City, CA) ; Satsuta;
Eugene; (Saratoga, CA) ; Scheinkman; Luiz;
(Sunnyvale, CA) |
Correspondence
Address: |
FINNEGAN, HENDERSON, FARABOW, GARRETT & DUNNER;LLP
901 NEW YORK AVENUE, NW
WASHINGTON
DC
20001-4413
US
|
Family ID: |
46322449 |
Appl. No.: |
11/203225 |
Filed: |
August 15, 2005 |
Related U.S. Patent Documents
|
|
|
|
|
|
Application
Number |
Filing Date |
Patent Number |
|
|
11111794 |
Apr 22, 2005 |
|
|
|
11203225 |
Aug 15, 2005 |
|
|
|
Current U.S.
Class: |
1/1 ;
707/999.103 |
Current CPC
Class: |
G06F 8/72 20130101 |
Class at
Publication: |
707/103.00Y |
International
Class: |
G06F 17/00 20060101
G06F017/00 |
Claims
1. A method for transforming a business application structure using
object-oriented programming structures, comprising: identifying a
plurality of related table-based data structures in the business
application; defining a transformation rule for converting the
related table-based data structures into an object-oriented
structure, wherein the object-oriented structure reflects data
relationships defined by the plurality of table-based data
structures; converting the related table-based data structures into
the object-oriented structure based upon the transformation rule;
and expressing the object-oriented structure as an object-oriented
programming structure that models the business application
structure.
2. The method of claim 1, wherein defining the transformation rule
further comprises: identifying attributes that are common to a
plurality of related business data structures; identifying
attributes that are not common to the plurality of related business
data structures; and defining a transformation rule to create an
encompassing object-oriented structure to model the attributes that
are common to the plurality of related business data structures and
to create an encompassed object-oriented structure to model the
attributes that are not common to the plurality of related business
data structures.
3. The method of claim 2, wherein defining the encompassing
object-oriented structure comprises a superclass, and the an
encompassed object-oriented structure comprises a subclass of the
superclass.
4. The method of claim 1, further comprising: providing a user
interface to hierarchically display the object-oriented programming
structure to a user.
5. The method of claim 1, wherein the business application is a
payroll business application, the table-based data structure
reflects a wagetype, and the object-oriented structure is an
object-oriented programming language class structure.
6. The method of claim 1, wherein expressing the object-oriented
structure as an object-oriented programming construct comprises:
including value data from the business application in the
object-oriented programming structure.
7. A method for modeling data structures from a business
application in an object-oriented programming language, comprising:
identifying a plurality of business objects in the business
application; identifying a plurality of attributes common to the
plurality of business objects; defining an object-oriented
programming language superclass to model the plurality of business
objects, wherein the superclass includes a plurality of variables
corresponding to the plurality of attributes common to the
plurality of business objects; defining an object-oriented
programming language subclass to model a business object from the
plurality of business objects in the business application, wherein
the subclass includes a variable corresponding to an attribute not
among the plurality of attributes common to the plurality of
business objects; and instantiating an object from the subclass,
wherein the object represents the business object.
8. The method of claim 7, further comprising: displaying the object
representing the business object using an object-oriented
programming tool.
9. The method of claim 7, further comprising: detecting a problem
associated with the object representing the business object using
an object-oriented programming tool, wherein the problem
corresponds to a problem in the business object.
10. The method of claim 7, further comprising: manipulating the
object representing the business object using an object-oriented
programming tool.
11. The method of claim 10, further comprising: converting the
manipulated object representing the business object into a data
structure usable by the business application.
12. The method of claim 11, further comprising: loading the data
structure into the business application to affect an operation of
the business application.
13. The method of claim 7, wherein defining an object-oriented
programming language subclass to model a business object comprises:
including data values for the business object from the business
application in the subclass.
14. A system for modeling data structures from a business
application in an object-oriented programming language, comprising:
a first identifying component adapted to identify a plurality of
business objects in the business application; a second identifying
component adapted to identify a plurality of attributes common to
the plurality of business objects; a transforming component adapted
to define an object-oriented programming language superclass to
model the plurality of business objects, wherein the superclass
includes a plurality of variables corresponding to the plurality of
attributes common to the plurality of business objects, and adapted
to define an object-oriented programming language subclass to model
a business object from the plurality of business objects in the
business application, wherein the subclass includes a variable
corresponding to an attribute not among the plurality of attributes
common to the plurality of business objects; and a tool component
adapted to instantiate an object from the subclass, wherein the
object represents the business object.
15. The system of claim 14, further comprising: a screen for
displaying the object representing the business object using an
object-oriented programming tool.
16. The system of claim 14, further comprising: an object-oriented
code analysis component for detecting a problem associated with the
object representing the business object using an object-oriented
programming tool, wherein the problem corresponds to a problem in
the business object.
17. The system of claim 14, further comprising: a user interface
for manipulating the object representing the business object using
an object-oriented programming tool.
18. The system of claim 17, further comprising: a converting
component adapted to convert the manipulated object representing
the business object into a data structure usable by the business
application.
19. The system of claim 14, further comprising: a communications
interface for loading the data structure into the business
application to affect an operation of the business application.
20. The system of claim 14, wherein the transforming component
adapted to define an object-oriented programming language subclass
to model a business object is adapted to include data values for
the business object from the business application in the subclass.
Description
RELATED APPLICATIONS
[0001] This application is a continuation-in-part of U.S. patent
application Ser. No. 11/111,794, entitled "Systems and Methods for
Modeling and Manipulating a Table-Driven Business Application in an
Object-Oriented Environment," filed Apr. 22, 2005, which is
incorporated herein by reference.
BACKGROUND
[0002] 1. Relevant Field
[0003] The present inventions generally relate to business
application software. More particularly, the inventions relate to
systems, methods and computer readable media for object-oriented
programming (OOP) modeling of business applications and the use of
an OOP model to create, improve, and maintain a business
application.
[0004] 2. Background Information
[0005] One drawback with legacy business application systems stems
from how business data and rules are often contained in physically
separate table data structures, with little user-friendly
representation of the organization or relationships of those
structures. Such table-driven systems are difficult to work with.
For example, a business object may be defined across ten or more
different database tables that are not easily accessed, displayed,
or understood together.
[0006] Furthermore, as shown in the example of FIG. 3A, a
table-driven business application typically stores its
configuration data 305 and its rules 310 in multiple, physically
separate tables. Considered statically, there is no obvious or
easily determined relationship or connection 315 between
configuration data 305 and rules 310. At runtime, however,
configuration data 305 and rules 310 interrelate 320 because the
configuration data 305 and the rules 310 affect each other. For
example, some configuration data 305, may affect the execution of
rules 310. The physical separation between related data and between
data and rules, the lack of static indications of runtime
interactions between data and rules, and other factors make the
data and processes of a business application difficult to
understand, difficult to create, difficult to debug, and difficult
to modify without causing unexpected effects.
[0007] In view of the foregoing, it is desirable to take business
application structures and translate them into user-friendly
objects that can be more easily understood, manipulated, debugged,
designed, redesigned, analyzed, and/or modified.
SUMMARY
[0008] Consistent with embodiments of the present inventions,
systems, methods and computer readable media are disclosed for
modeling of business applications and the use of an OOP model to
create, improve, and maintain a business application.
[0009] Embodiments and implementations consistent with the present
invention provide systems and methods for transforming a business
application structure using object-oriented programming structures.
The system and method embodiments may perform operations
comprising: identifying a plurality of related table-based data
structures in the business application; defining a transformation
rule for converting the related table-based data structures into an
object-oriented structure, wherein the object-oriented structure
reflects data relationships defined by the plurality of table-based
data structures; converting the related table-based data structures
into the object-oriented structure based upon the transformation
rule; and expressing the object-oriented structure as an
object-oriented programming structure that models the business
application structure.
[0010] It is to be understood that both the foregoing general
description and the following detailed description are exemplary
and explanatory only, and should not be considered restrictive of
the scope of the invention, as described and claimed. Further,
features and/or variations may be provided in addition to those set
forth herein. For example, embodiments of the invention may be
directed to various combinations and sub-combinations of the
features described in the detailed description.
BRIEF DESCRIPTION OF THE DRAWINGS
[0011] The accompanying drawings, which are incorporated in and
constitute a part of this disclosure, illustrate various
embodiments and aspects of the present invention. In the
drawings:
[0012] FIGS. 1 to 3A illustrate exemplary business structures of a
business application;
[0013] FIG. 4A illustrates a flowchart illustrating an overview of
an exemplary process 400 for creating an off-line model of a
business application, consistent with the present invention;
[0014] FIG. 4B is an exemplary illustration 440 of the various
processing tools consistent with the invention;
[0015] FIGS. 5, 6A, and 6B illustrate exemplary processes
consistent with the present invention;
[0016] FIG. 7A illustrate an exemplary processes consistent with
the present invention;
[0017] FIG. 7B illustrates an exemplary OOP structure consistent
with the invention;
[0018] FIG. 7C illustrates a block diagram of an exemplary
architecture consistent with an embodiment of the invention;
[0019] FIG. 8 illustrates an exemplary processes consistent with
the present invention;
[0020] FIGS. 9 to 15 illustrate exemplary processing tool
operations consistent with the present invention;
[0021] FIG. 16 illustrates an exemplary process consistent with the
invention; and
[0022] FIGS. 17 to 56 illustrate exemplary user interface displays
consistent with the present invention.
DETAILED DESCRIPTION
[0023] The following detailed description refers to the
accompanying drawings. Wherever possible, the same reference
numbers are used in the drawings and the following description to
refer to the same or similar parts. While several exemplary
embodiments and features of the invention are described herein,
modifications, adaptations and other implementations are possible,
without departing from the spirit and scope of the invention. For
example, substitutions, additions or modifications may be made to
the components illustrated in the drawings, and the exemplary
methods described herein may be modified by substituting,
reordering, or adding steps to the disclosed methods. Accordingly,
the following detailed description does not limit the invention.
Instead, the proper scope of the invention is defined by the
appended claims.
Overview
[0024] Systems and methods consistent with the invention generally
relate to business application software. Exemplary business
applications include those offered by SAP, built around the SAP R/3
system. These business applications may provide the capability to
manage financial asset and cost accounting, as well as production
operations and materials, personnel, plants, and archived
documents. The R/3 system runs on a number of platforms including
Windows 2000 and uses the client/server model. The R/3 system is a
comprehensive set of integrated business applications. R/3 provides
the ability to store, retrieve, analyze, and process corporate data
used for financial analysis, production operation, human resource
management, and other business processes. At one level, an R/3
system (or other legacy business application system) may be thought
of as a collection of legacy business structures or business
objects held primarily in databases (as tables) that are
manipulated by business processes or workflows.
[0025] For example, as shown in FIG. 1A, an exemplary business
structure includes configuration data 100, which may be one or more
business data objects containing data used by a business process.
Configuration data 100 may include several data fields called
attributes, such as "attribute 1" 105 through "attribute n" 120.
For example, configuration data 100 may include data such as an
employee's name, an hourly wage rate, and indicators for directing
processing of data for the employee. Exemplary business structures
also include business rules, such as rule 125, which are typically
made up of multiple operations, such as "operation 1" 130 through
"operation n" 140. Rule 125 may reflect a series of operations that
when executed will, for example, cease deducting social security
payments after an employee's cumulative salary reaches a specified
amount.
[0026] In systems such as R/3, configuration data and rules control
the business application software. As shown in FIG. 2A, in an
exemplary payroll processing business application, the business
structures may include a wagetype 200, which may be a business data
object containing configuration data used to configure portions of
a paycheck. For payroll processing purposes, each employee may have
associated with him or her one or more wagetype structures
containing data about the employee that is used to perform the
payroll functions. For example, an employee may have a wagetype for
hourly rate, a wagetype for union fees, a wagetype for deductions,
etc. Each wagetype may include one or more attributes 205 that act
as configuration elements, shown as attributes A-H. The attributes
themselves may be of different types. For example, as shown,
attributes A-C may be processing class attributes, which control
the processing path used by the business application when
performing processing (rules) for the employee. Attributes D-F may
be cumulation attributes, which identify wage types that relate to
one another and are processed together in some instances.
Attributes G and H may be evaluation class attributes, which
control processing paths like processing class attributes, but for
different rules. A wage type 200 may include other types of
attributes 205, as well.
[0027] As shown in FIG. 2B, as one of its functions, an exemplary
payroll processing application 215 takes employee data 210 as input
and produces a paycheck 220 as output. At runtime, each employee
record is processed based on the employee's data 210 to produce the
employee's paycheck 220.
[0028] FIG. 2C illustrates the exemplary process of FIG. 2B in
greater detail. As shown in this example, employee data 210 is
contained in the employee's wagetype(s) 200 or in one or more
similarly organized data structures. These data structures contain
the data used by, and to control, process 215 that calculates and
produces a paycheck 220.
[0029] More specifically, employee data 210 from the employee wage
type 200 may be used by a workflow or schema that implements
payroll process 215. In the example shown, the first function of
payroll process 215 may be the "HRS.times.RATE" function 225, which
may multiply the employee's hours worked by the employee's hourly
wage rate. The data specifying the hours and hourly rate may be
derived from the employee's wage type 200. As shown in this
example, information regarding how to perform the "HRS.times.RATE"
function 225 is specified by a rule(s) 226 (rule "A" in FIG. 2C)
associated with function 225. The functioning of the rule(s) 226,
and thus the functioning of the "HRS.times.RATE" function 225, may
be affected by attributes 205 contained in the employee's wage type
200. For example, as shown in FIG. 2A, a processing class attribute
205, such as attribute A, may have "L" selected for this employee
and "R" unselected. Selecting "L" may cause rule(s) 226 associated
with the "HRS.times.RATE" function 225 to calculate the product in
a different manner than if "R" were selected for attribute A. For
example, "L" may cause the hourly rate to increase by 1.5 for hours
greater than 40, such that the employee gets paid time and a half
for overtime beyond 40 hours, while "R" would not use an hourly
rate increase, for an employee who is not eligible for increased
overtime pay.
[0030] As shown in FIG. 2C, the next function to be performed in
the workflow may be either the "ADD BONUS" function 230 or the
"SUBTRACT TAXES" function 235. Typically, data from the employee's
wage type 200 will indicate whether the employee is to receive a
bonus and control the workflow to determine which of the two
functions is performed next. As explained with respect to the
"HRS.times.RATE" function 225, the rules associated with the "ADD
BONUS" function 230 or the "SUBTRACT TAXES" function 235 (rules "B"
and "C," respectively, of FIG. 2C) determine how those functions
are performed, and attributes 205 from the employee's wage type 200
may affect the functioning of the rules.
[0031] Similarly, the "SUBTRACT DEDUCTIONS" function 240, "SUBTRACT
ALIMONY" function 245, and "CUMULATE" function 250 are performed as
the illustrated workflow progresses, and the rules associated with
each function may be similarly affected by the corresponding
attributes 205 in the employee's wage type 200. As shown in FIG.
2C, rules "D," "E," and "F" correspond to functions 240, 245, and
250, respectively. After all the workflow functions are completed,
the payroll process shown produces a paycheck 220 for the employee
reflecting the results of the operations carried out by the various
functions.
[0032] Other business applications, such as financial applications,
asset accounting applications, cost accounting applications,
production operations applications, etc., use business structures
and workflows comparable to the payroll processing application
illustrated in FIGS. 2A-2C.
[0033] FIG. 3B illustrates an exemplary business system
architecture to which embodiments of the invention may be applied.
As shown, a business system 330, such as an SAP R/3 system, may
include several business applications, such as business application
A 340, business application B 350, and business application C 360.
A business application, may be, for example, a payroll application
that calculates the payroll for a company, generates paychecks or
payslips for each employee, etc.; a human resources application
that manages employee data, adds new employee records, deactivates
retired employee records, etc.; or some other type of business
application.
[0034] A typical legacy business application, such as a payroll
application exemplified in this example by business application A
340, is table-driven. In other words, the data which controls
execution of the application is contained in database tables. The
application is designed to read and traverse the tables and execute
business functions or processes according to the contents of the
database tables. Multiple applications run on the same physical
hardware and from data contained in the same relational
database(s).
[0035] At a high level, payroll business application A 340 may be
thought of as consisting of basically three major logical parts:
(1) a data dictionary 342 that describes all the tables related to
the application, (in this case payroll), (2) source code 344 that
is the driver of the business processes within the business
application, and (3) configuration data 346 that control the
operation of the business processes within the business
application. Each application in business system 330, such as
business application B 350 and business application C 360,
typically has its own data dictionary, source code, and
configuration data. Configuration data is typically very
application specific, while some data dictionary business objects
and some source code may be shared among business applications.
[0036] Data dictionary 342 contains information about the business
that is used by the business application, such as information about
the employees used by the payroll application, for example,
information regarding when a new employee joined the company.
Configuration data 346 contains information controlling the
operation of business application A 340 and is typically stored in
database tables accessible to users who can customize the payroll
application for their business needs by modifying configuration
data 346. Some embodiments consistent with the invention focus on
modeling configuration data 346, which controls the operation of
business application source code 344, such as the payroll
driver.
[0037] In one embodiment, configuration data 346 may be logically
modeled by several major business objects. For example, an SAP R/3
business system payroll application may be modeled as major
business objects such as wagetypes, schemas, and rules. Further,
major business objects may be logically modeled as containing one
or more sub-objects such as processing class, evaluation class, and
cumulations, for an R/3 wagetype. The configuration data in the
modeled objects describes how the business application is
configured for a specific user, such as a specific company.
[0038] Source code 344 represents a driver for the business
processes within the business application. The application source
code driver of the business application is essentially just a
framework that needs the configuration data to tell it how to
operate. Without the configuration data to tell it how to work, the
source code cannot work meaningfully. The source code driver 344
knows how to execute any schema, which is part of configuration
data 346, and a schema is required to run an application; e.g., a
payroll schema is required to run a payroll business
application.
[0039] Payroll driver 344 knows how to read a schema table and do
what the schema table says. A schema may be considered a work flow
description. For example, in an R/3 system, the business
application source code, such as payroll driver source code 344, is
basically designed to navigate or traverse the configuration
database tables that stores a schema(s). Business application
driver 344 reads the schema table row by row, takes the data out of
the schema tables, and executes the rules associated with a
specific function of the schema. These rules are affected by the
data in the associated wagetypes. So a schema, and it's associated
rules, needs a wagetype to direct it's functioning. These business
objects are all interrelated.
[0040] In a table-driven business system application, such as an
R/3 payroll business application, a wagetype business object (or
its equivalent) may modify the functionality of a schema, and the
data in the wageype can be configured by a user or whoever
configures the payroll application. For example, consider a simple
schema to calculate A and calculate B. The calculate B function and
calculate A function are executable by driver source code 344
running the schema. But the order of execution of function A and
function B, that is, whether to calculate A and then calculate B,
or calculate B and then calculate A, is determined by the schema
business object in configuration data 246, which is consulted by
payroll application source code 344 when executing. A user can
modify the schema business object and thus modify the configuration
of business application 340. Source code may contain the executable
statements implementing the algorithms of how to calculate A and
how to calculate B, but the connection and the order is determined
by the configuration data.
[0041] For another example, consider a rule business object that
includes five calculation algorithms for a particular value.
Configuration data, (e.g., in a wagetype object), may be set so
that one algorithm is used for a specific group of employees at
time X. At time Y, some legislation change or a union negotiation
for the group of employees may take place and cause a need for a
change for this particular group to switch to another calculation
algorithm. To make the change, a user may modify a wagetype for
this group employees in the business application by changing their
processing class values so that they use another algorithm in their
payroll calculations.
[0042] Common source code 370 represents code (and other business
objects) that are stored in a common code base that business
applications share among themselves. Consequently, in legacy
business systems, including R/3, there may be no clear separation
between the logical instances of execution or the logical instances
of the data in a business application. Thus, when a user configures
a part of a business application that is common to other
applications, e.g., in common source code 370, the user may affect
many different instances of objects at execution. It is very
difficult to verify that the changes made to the common code are
correct for each and every business application that uses it,
because they all must be tested to be sure.
[0043] In addition, configuration data 346 may be changed or
created that causes the unintended and/or incorrect use of objects
stored in common source code 370. For example, in an SAP R/3
payroll business application, a user may configure a United States
schema to use a Brazilian tax calculation function, which is
accessible from common source code 370. This is not correct,
however, as the Brazilian tax function will perform a different
calculation than a United States tax function.
[0044] As noted above, the data structure business objects, like
wagetypes, and the functional business objects, like rules, are
very interconnected and changes to one will typically affect the
other. For example, changing part of a payroll application data
structure object, such as a wagetype or a processing class of a
wagetype, will likely affect the calculations for multiple
employees done by multiple rules and related to multiple other
wagetypes. And vice-versa. Consequently, in the table-based and
table-organized form native to business system 330, data structure
business objects and functional business objects are difficult to
understand, maintain, modify, debug, optimize, and correctly
manipulate.
[0045] Some embodiments of systems and methods consistent with the
invention represent business application objects as object-oriented
programming language elements, building a model of the business
application in some respects, and applying object-oriented
programming language tools to the model. The model and the tools
improve a user's ability to understand, maintain, modify, debug,
optimize, and correctly manipulate the business application, as
represented by the object-oriented programming language model.
[0046] In some embodiments consistent with the invention, anything
that is related to the configuration of the business application
may be considered a business object for transformation to an
object-oriented programming language element(s). In one embodiment,
a designer may select and define the business objects that are to
be modeled as OOP objects. This selection and definition of
business objects may be done using one or more different
techniques, but generally the designer's goal should be to define
business-application-layer objects, which are logical collections
of things (data, operations, etc.) reflecting the design and
functionality of the business application, and not objects based on
the implementation or data structures that implement the business
application, such as data-dictionary-layer structures. A business
application typically uses a relational database model, but
business object definition typically should not be based on the
database relationships as they usually do not coincide with the
logical business functionality.
[0047] In one technique, a designer may analyze the outputs of a
business application and decide that the output data structures
should be business objects in the business application model. For
example, running a payroll application on an SAP R/3 system
produces a table of result wagetypes, making wagetypes a clear
candidate for a business object to be transformed into an OOP
object. Smaller data structures that are part of larger data
structures, such as processing classes, cumulations, and evaluation
classes that are part of a wagetype, are also obvious candidates
for transforming into OOP objects.
[0048] A designer may also analyze the business application to
identify business entities that are treated as logical collections
of data and/or associated operations by the business application,
as these are also logical candidates for definition as business
objections. For example, an SAP R/3 payroll application provides
user interfaces to configure wagetypes, schemas, and rules to
customize the application, treating them as logical entities. Thus,
wagetypes, schemas, and rules may be considered business objects
for modeling by OOP language elements. Logical business entities
that encompass other logical entities may be decomposed to model as
objects the encompassed logical entities that comprise them, such
as decomposing wagetypes into processing classes, cumulations, and
evaluation classes business objects.
[0049] After the business objects that comprise a model of a
business application are defined, embodiments of systems and
methods consistent with the invention may map them to specific
object-oriented objects and elements. This may be done by analyzing
the attributes of a business object and transforming them into an
object-oriented language element, such as a Java.TM. language
element that appropriately models the business object attributes.
This process involves finding a corresponding construct, structure,
or other element within the destination object-oriented language to
represent each important attribute, element, or relationship of the
business object being transformed. For example, an object-oriented
language class, such as Java.TM. class, may be used as a starting
point to represent most business objects. Business objects that are
basically data structures, such as wagetypes in an R/3 payroll
application, may be represented using static OOP elements in an OOP
object such as a class, for example, as shown in FIG. 7A (and
explained further below). Business objects which contain executable
code constructs, such as rules and schemas in an R/3 payroll
application, may be represented using OOP objects having code, such
as a class with methods or functions, for example, as shown in FIG.
25 (and explained below). Other object-oriented language features
may also be used to model business object attributes. For example,
object-oriented language superclasses and subclasses may be used to
model the hierarchy and inheritancy attributes of business objects,
and object-oriented language scope elements, such as public and
private, may be used to model the scope attributes of business
objects, etc.
[0050] This mapping process may be automated by defining a set of
mapping rules used by a conversion engine to take input business
object data for business objects and convert it into a
corresponding object-oriented language object as described further
below.
[0051] In addition to transforming business objects into
corresponding object-oriented language objects, elements, etc.,
embodiments of systems and methods consistent with the invention
may also use code-development-project-organization-tool features to
model a business application. For example, as noted above, a legacy
business system 330 typically shares common code and data
structures 370 among business applications, so if something is
changed in the common code, i.e., in the common parts, it affects
every object or structure that uses that common part. One way to
represent this feature of a business application in an
object-oriented model may be to use code development project
features and shared folders. For example, in many legacy
table-based business systems like R/3, many business objects have a
common configuration across runtime instances of the application,
but each instance itself is independent, and different, at runtime.
For a specific example, consider a business application used for a
division of a business in Argentina and a division of the business
in the United States. The application is configured using the same
type of configuration tools for Argentina and the United States,
but the running configurations of the application for each country
are totally separate, and the same configuration objects within the
context of the Argentine run of the application can mean different
things than within the context of the United States run. They are
like separate universes. Both universes, however, have a common
foundation of business objects that are shared. These relationships
and behaviors of the business application may be modeled using
separate projects to hold, delimit, and manage the United States
instances of the application objects and the Argentine instances of
the application objects and by using shared folders to hold,
delimit, and manage the common objects. Similarly, other OOP
language development environment features, in addition to projects
and shared folders, could also be used to model business
application/business system features.
[0052] A designer modeling such aspects of a business system and
business application may look at the relationships within the
business system/application to identify "vertical dimensions" and
"foundation" elements for projects and folders. A dimension may be
thought of as an instance of all the objects involved in a process.
A foundation element may be thought of as a common element that is
used by many instances. So if an application uses the same
structure more than once, but the data is different each time
(i.e., there are many instances of the same structure), then these
may be modeled as different dimensions (projects) with a common
foundation (shared folder). Thus an object-oriented model of a
business application/system organized by projects and shared
folders enables demonstration and evaluation of the effects to the
dimension(s) of modifying a foundation element. Put in
object-oriented terms, a foundation element may perhaps be
analogized to a class definition for an object, while a vertical
dimension may be analogized to an instance of the class object.
Each instance may be the same architecturally, yet the data in each
one is different. Such analogies and may be useful to a designer
modeling complex table-driven business applications and systems
having shared code and data structures and building transformation
rules for converting business application objects and applications
into object-oriented language representations.
[0053] Systems and methods consistent with the invention analyze a
business application's data, operations, and relationships and
create a corresponding object oriented programming (OOP) model
corresponding to the business application entities. In one
embodiment the OOP model may be realized in the Java programming
language and may include OOP objects, functions, and operators.
Each OOP model accurately represents the data, relationships, and
rules associated with the corresponding business entity. Once
converted to an OOP model, systems and methods consistent with the
invention may use standard OOP tools to understand, manipulate,
design, redesign, analyze, and modify the business application.
This can be done independently of the native business application
system, as the OOP model is separate and independent from the
business application entities. Modifications made to the OOP model
may then be converted back into business application entities and
installed in the native system.
Detaching Application into Offline Mode
[0054] FIG. 4A illustrates a flowchart illustrating an overview of
an exemplary process 400 for creating an off-line model of a
business application, consistent with the present invention. The
exemplary process is applied to a business application composed in
a first programming format. The programming format for such
business applications are often specialized programming formats
unique to each particular business application and, as described
above, typically have limited flexibility in how a programmer may
conduct efficient programming or debugging tasks.
[0055] As shown in FIG. 4A, systems consistent with the invention
may translate the business application into a model representing
the business application (stage 410). More particularly, the model
reflects a representation of the business application in a second
programming format different than the original or first programming
format of the business application. In preferred embodiments of the
invention, the second programming format may be an OOP language,
such as Java or C++. The process for translating the business
application into a model is described in greater detail below with
respect to FIGS. 5 to 8.
[0056] Once the system has generated the model of the business
application, the system may then enable a user to process the model
in a processing environment or platform corresponding to the second
programming format (stage 420). For example, as described above,
the second programming format may be an OOP language, such as Java.
Systems consistent with the invention may thus enable a user to
program, debug, or analyze the programming code of the model by
using an OOP editor or other type of OOP processing environment or
platform. Because the user may process the model, as opposed to the
actual business application, the user may do so while business
application is still running. Thus, systems consistent with the
invention allow a user to process a business application without
interfering with normal business activities.
[0057] Further, by taking advantage of processing tools available
with such OOP processing environments, the system may enable a user
to use one or more tools to process the model. FIG. 4B is an
exemplary illustration 440 of the various processing tools
consistent with the invention. As shown in FIG. 4B, the system may
enable a user to apply the processing tools to the model of the
business application (stage 445). These processing tools may
include a deprecation process (stage 450), a refactoring process
(stage 455), a runtime error process (stage 460), a development
process (stage 465), an optimization process (stage 470), a design
tools process (stage 475), and a version compare process (stage
480). These and other processing tools consistent with the
invention are described in greater detail below with respect to
FIGS. 9 to 15. Further, FIGS. 17 to 56 illustrate exemplary user
interface screens enabling a user to process the model representing
the business application.
[0058] The system may then re-translate the model representing the
business application in the second programming format back to the
first programming format (stage 430). As described below, systems
consistent with the invention may translate the model in such a way
that any modifications made to the model in the second programming
format are automatically reflected in the re-translated business
application composed in the first programming format. The process
for re-translating the model back to the first programming format
is essentially the reverse of the forward translation process
described above with respect to stage 410, and as illustrated below
with respect to FIGS. 5 to 8.
[0059] FIG. 5 illustrates the exemplary modeling process 500 of
FIG. 4 in greater detail. As shown in FIG. 5, to translate the
business application into the second programming format, the system
receives the logic entities of the business application composed in
the first programming format (stage 510). As described above with
respect to FIG. 1, these logic entities may be the business data
structures (e.g., configuration data 100 and business rules 125) of
the business application. Based on the received logic entities of
the business application, the system may then generate a model
representing the business application in the second programming
format (stage 520). As also describe above, the second programming
format may be, for example, an OOP language such as C++ or Java.
The system may then, as described above with respect to FIG. 4,
process the generated model of the business application (stage
530). The system may then re-translate the processed model to
regenerate the business application in the first programming format
(stage 540).
Generating a Model of a Business Application
[0060] FIG. 6A illustrates an exemplary process 600, consistent
with the invention, for translating the business application into a
model composed in the second programming format. As shown in FIG.
6A, the system may receive the data structures, which may be
table-based data structures, of the business application (stage
610). In this regard, the system may scan the business application
to identify the table-based data structures, which may be any group
or segment of data reflecting data stored in a table-based format
of the business application. The table-based data structures may,
for example, correspond to the configuration data and rules of the
business application. Further, each table-based data structure may
include attributes of the data stored in the respective table-based
data structure. For instance, as explained above with respect to
FIG. 1, a table-based data structure may include configuration data
100 having attributes 105 to 120 or a rule 125 having operation
attributes 130 to 140.
[0061] The system may then select the minimum set of attributes of
table-based data structures that uniquely define the table-based
data structures (stage 620). To this end, the system may first
identify those attributes of, for example, the configuration data
(e.g., attributes 105 to 120) and any rules (e.g., operation
attributes 130 to 140). The system may then identify those
attributes that are common to each table-based data structure. From
the identified common attributes, the system may then select the
least number of these common attributes that uniquely defines each
translational data structure.
[0062] Based on the selected minimum set of attributes, the system
may then define one or more translational data structure(s) (stage
630). In systems consistent with the invention, a translational
data structure may be an identified data or business structure of
the business application that is converted into an object-oriented
structure. For example, in an R/3 payroll application, the minimum
set of attributes may include a geographic attribute (e.g., "New
Zealand"), a version reference attribute (e.g., "ma"), and a client
reference attribute (e.g., "800"). The corresponding translational
data structure may thus be defined as NewZealand.ma.800. In OOP
terms, the defined translational data structures may include at
least one translational data structure that respectively
corresponds to a project, an object, and an object instance. The
system may then generate the model of the business application
based on the defined translational data structures (stage 640).
[0063] FIG. 6B illustrates an exemplary process 650 further
describing the processing stages of FIG. 6A. As shown in FIG. 6B,
the system may receive table-based data structures corresponding to
configuration data and rules of business application (stage 660).
The system may then identify the attributes of received
configuration data (stage 665) and identify the attributes of
received rules (stage 670). The system may then determine those
attributes common to the identified configuration data and to the
rules of the business application (stage 675). From these common
attributes, the system may then select the minimum set of common
attributes that uniquely define a translational data structure
(stage 680).
[0064] As noted above, methods and systems consistent with the
invention may transform business application logic entities or
structures into OOP structures that represent the data,
relationships, and operations of the business application
structures. In one embodiment, the business application structures
are transformed at the application level, including consideration
of application logic, as opposed to the database table level. Thus,
a complex business structure comprising ten or more related
database tables, such as a wagetype in an SAP R/3 payroll
processing application, may be transformed into a single OOP
structure, such as a Java class, that encompasses all the
information in the ten or more related database tables.
[0065] In some embodiments consistent with the invention, business
structures are transformed into a hierarchical object-oriented
class structure. For example, as described above, all the related
business structures in a business application may be analyzed to
identify common elements or attributes, and transformation involves
defining an OOP superclass that represents the common elements.
Then, specific business structures are analyzed to identify their
unique elements, and each specific business structure is
transformed into an OOP structure by defining subclass instances of
the superclass, which add representations of the unique elements of
each specific business structure to the superclass. This exposes
the hierarchy of the business structures to a user or administer
viewing the OOP structures, and allows manipulation of the OOP
representations of the business structures by OOP design and
development tools. In one embodiment, included in the
transformation to OOP subclasses is extraction of the data from the
business structure for inclusion in the subclass. Thus, the values
of various fields are also exposed to users and OOP tools.
[0066] Processes consistent with the invention for generating an
OOP model of a business application are described in further detail
below with respect to FIGS. 7 and 8. FIG. 7A, for example,
illustrates an exemplary OOP structure consistent with the
invention. Referring briefly back to FIG. 2A, recall the example of
a wagetype business structure 200 from a payroll application of an
SAP R/3 system, which may have several attributes 205, such as
several processing class attributes. An implementation consistent
with the invention may transform the data from a specific wagetype
business structure 200, for example the wagetype structure known as
"/123," into an OOP structure such as a subclass that extends a
"wagetype" superclass as shown in FIG. 7A. The transformation
process creates a valid OOP language name "wagetype_s123" 792 based
on the business structure name "/123" and declares it as a subclass
of the superclass wagetype 794. The OOP structure corresponding to
business application wagetype/123 contains and models the data and
relationships 796 of the business application wagetype/123
extracted from the database tables of the business application. In
the example shown, included in the OOP structure are code lines
that model the processing class attributes 798 of the business
application structure wagetype/123. Also included in the example
shown is documentation 795 related to the business application
structure wagetype/123, which may be used and displayed by OOP
tools such as JavaDoc.TM..
[0067] In some embodiments, transformation may be based on a set of
rules mapping or defining what OOP structure may create or define
each business structure encountered in the business application. In
one embodiment, the set of transformation rules may be defined
manually. The rules for translating a business application
structure into an OOP structure may create syntactically correct
OOP structures (e.g., in Java.TM. code) useful for processing at
the business application level. For example, one transformation
rule for mapping various business structures into OOP structures
may be to group them according to whether they share operations
that can be performed on them. Another rule may be to create a
subclass for each different time period attribute of a business
structure based on start date and end date value of the time period
attribute. Another rule may be to, within a subclass, define each
business structure configuration element, such as processing class
attribute, as an OOP operation in that class. Yet other rules may
define when to use a public, private, or shared OOP class
attributes to determine the scope and visibility of each OOP
structure. Yet another rule may be to take each business structure
as defined by the business application and create a corresponding
OOP structure, effecting a one-to-one conversion mapping.
[0068] FIG. 7B illustrates an exemplary process consistent with the
invention for translating, for example, configuration data. As
shown, the process begins by defining transformation rules for
converting table-based data structures of a business application
into object-oriented structures (stage 710). Next, the process
scans the business application to identify a table-based data
structure (stage 720). Next, the process converts the identified
table-based data structure into an object-oriented structure,
according to the transformation rules (stage 730).
[0069] The process then determines whether all the table-based data
structures in the business application have been converted into
object-oriented structures (stage 740). If not (stage 740, No), the
process loops up and continues to identify and convert. If so
(stage 740, Yes), then the process expresses the object-oriented
structures in an object-oriented programming construct, such as an
OOP class (e.g., a Java.TM. class) that represents the table-based
data structure.
[0070] FIG. 7C is a block diagram of an exemplary architecture,
consistent with an embodiment of the invention, for transforming a
business application. As shown, a business application 755, such as
the Payroll application in an SAP R/3 system, includes business
application structures 757, which are logical entities embodied in
various database tables or other data formats. In one embodiment,
business application 755 is a preexisting application (such as the
an application in an SAP R/3 system) that has been modified by
adding remote function calls 760 that retrieve business application
structures at the request of an outside application.
[0071] In the embodiment shown, extract module 765 implements a
process that retrieves business application structure data from the
business application and readies the data for transformation into
an object-oriented structure. For example, extract module 765 may
send a data request via remote function call 760 to business
application 755 and receive, in response, all the appropriate
application data about a business structure 757, including context
data about business structure 757. The application data from
business application 755 may also include information about the
data, e.g., documentation describing the data. In the embodiment
shown, extract module 765 maintains a context directory 770
containing information regarding what context is needed for each
activity and a translation module 775 that translates the business
application data into XML, or a similar markup language.
[0072] Transform module 780 receives the XML-formatted business
application data from extract module 765. Transform module 780
contains an embedded conversion mapping component 785 that is used
in transforming the XML-formatted business application data into an
object-oriented structure. Conversion mapping component 785
includes transformation rules, as described above. For example, a
business application structure logic entity, such as a "standard
deduction" application structure (which may consist, in business
application 755, of a number of physical database tables containing
various content data), may be mapped with a conversion algorithm
into a Java.TM. class or a set of Java classes. In one embodiment,
the name of the resulting object-oriented structure may typically
correspond to the name of the logic entity from business
application 755. For example, the model representing business
application 755 may include a "standard deduction" Java.TM. class,
and instances of the class representing each type of standard
deduction in business application 755. Documentation information
describing the business application structure from business
application 755 may be transformed into comments, such as Java.TM.
language source code comments, or the like and associated with the
OOP construct created to represent the business application
structure.
[0073] Transform module 780 provides the object-oriented structure
representing a business application structure to an object-oriented
language tool 790, such as a Java.TM. integrated development
environment tool, a Java.TM. code optimizer, a configuration
management tool, etc or an integrated development environment, such
as Eclipse.TM. (www.eclipse.org), that incorporates many software
development tools. Object-oriented language tool 790 may be used to
understand, maintain, develop, design, redesign, modify, configure,
or otherwise manipulate the OOP model of business application 755.
For example, a customized wagetype editor/viewer may be included as
part of an integrated development environment for an SAP R/3
system, presenting object-oriented structures such as the class
shown in FIG. 7A on easy to understand, use, and navigate user
interfaces, such as the examples shown in FIGS. 22 and 23.
[0074] In one embodiment consistent with the invention, extract
module 765, transform module 780, and object-oriented language tool
790 may be implemented on a computer(s) separate from the computer
implementing business application 755, such that business
application 755 can be modeled, and the OOP model manipulated,
without interfering with the ongoing operation of business
application 755. Further, one of ordinary skill will recognize that
Java.TM. is merely used as one example of an OOP language, and that
the scope of the invention includes other OOP languages, such as
C++, C#, Visual Basic, etc.
[0075] As with data structures (e.g., for configuration data) in
legacy business applications, the operations, instructions, or
business rules that implement the application are also typically
table-based. That is, the operations that perform a business rule
function, such as deducting payroll taxes from an employee's
paycheck, (and some of the relationships between the operations),
may be contained in database tables. The operations may be executed
by application source code that traverses the tables when carrying
out a particular rule. And, similar to business data structures,
business rules or operations may be contained in many different
database tables, which entail the same drawbacks described above
for table-based business data structures. Perhaps worse, there may
be no physical connection between the rules tables and the data
tables they operate on and vice-versa. Just as with table-based
business application structures, these table-centric rules and
operations are difficult for users and administrators to
comprehend, manage, create, revise, maintain, and debug.
[0076] Embodiments of methods and systems consistent with the
invention transform business application operations, rules, and
schemas into OOP constructs that represent the operation, rule, or
schema, emulate its operation in terms of sequence with other
operations, and represent its relationship(s) to the data it
operates with and upon. A rule may be thought of as a sequence of
operations that work on data structures to perform a business
function. A schema may be thought of as a business process or
workflow that connects a sequence of rules and data structures to
perform a more complex business function, for example, as
illustrated in FIG. 2C.
[0077] In one embodiment, an automated system determines each
operation that makes up a schema or rule in the business
application by analyzing the database table(s) that hold the schema
or rule, for example, by analyzing the rule tables in an
application in an SAP R/3 system or other business application. In
one embodiment consistent with the invention, for each business
operation found, the system transforms the operation into part of
an OOP model by declaring or creating an empty OOP language
construct with a similar name to that of the business operation,
such as a Java.TM. function or method. The system may insert a
standard number of parameters, or make other modifications, to make
the syntax of the newly declared OOP construct valid for the
programming format being used, such as the Java.TM. language. The
system preferably puts the OOP constructs in the same sequence as
the business application operations to form an OOP model object
representing the rule, schema, etc. that encompasses the business
application operations. Thus, in some embodiments consistent with
the invention, the system produces a model that represents the
configuration of the business application rules and schema, but not
their functionality, as the OOP constructs are null functions.
[0078] In one embodiment, the OOP language code representing the
business operations may contain function or method calls only,
while the bodies of the functions or methods are empty. OOP
languages such as Java.TM. allow a null function body and can
compile a function call with a null function body. For example, a
payroll business application for an SAP R/3 system may contain a
business rule with the operation "NUM=." An embodiment of a system
consistent with the invention may create a syntactically correct
null Java function named "NUM=" when modeling the payroll business
application. Thus, as noted, the system may produce a model that
represents the configuration of the business application rules and
schema, but not their functionality, as the OOP constructs are null
functions. Since the OOP language syntax is correct, OOP language
tools, such as compilers, analyzers, optimizers, etc. can be used
to find errors or problems in the configuration model, such as
errors in relationships, calls, interactions, design, etc.
associated with the modeled null functions. This is useful because
any errors associated with the model are also associated with the
business rules and operations it represents. For example, if a
modeled OOP function calls another OOP function that does not exist
(because there is no corresponding business application operation
that caused the called OOP function to be created in the model),
this error will be exposed by the OOP language tools, such as a
compiler or linker.
[0079] In some embodiments consistent with the invention, the OOP
functions include documentation pulled from the business
application to help users understand the function. In some
embodiments consistent with the invention, the process that
transforms business application operations or rules into OOP
constructs that represent the operation or rule is controlled by a
set of transformation rules. These transformation rules may be
generated manually. The transformation rules should be designed
such that the resulting OOP language function enforces the scope
and other characteristics of the business application operation
through OOP language techniques. For example, a business
application rule (and therefore the operations that comprise it)
may be valid for only one country, or in a few countries, or in all
countries. To enforce this scope, the transformation rules may
produce functions of appropriate scope, such as global, shared, or
local. In some embodiments, an OOP project model may also be used
to enforce the scope of OOP objects and functions.
[0080] In a manner similar to that explained above regard
transforming business application data structures into OOP
structures, the exemplary architecture shown in FIG. 7C may be used
to implement a system that also transforms a sequence of business
application operations (e.g., business application rules or
schemas), into object-oriented language constructs. In the
architecture shown, object-oriented tool 790 may include a
customized rule editor/viewer (not shown) as part of an integrated
development environment for an SAP R/3 system, presenting easy to
understand, use, and navigate user interfaces, such as the examples
shown in FIGS. 17 and 25. As explained further elsewhere in this
application, the OOP constructs representing the business
application rules and schemas may be modified, changed, optimized,
etc. using OOP language tools, and then reverse transformed back to
the business application format and the run in the business
application.
[0081] As with data structures (e.g., configuration data) and
operations (e.g., rules) in business applications, the
relationships or links between business objects, such as business
data and business operations, are also typically table-based,
making the relationships difficult, at best, to discern statically.
For example, as illustrated in FIG. 3, the relationships between
configuration data 305 and business rules 310 may not be realized
until runtime. This makes it difficult for users and administrators
to detect errors in the relationships, such as missing business
data that is referred to by other data or a business rule,
especially when working with the tables at any time other than run
time.
[0082] Methods and systems consistent with the invention transform
business application relationships or links into OOP constructs
that represent the relationship, tying together different types of
business objects, such as data and operations, in an easily
comprehensible and manageable manner, and in a manner that allows
automated OOP tools to check the integrity of the relationships. In
one embodiment, an automated system uses an object-oriented
language construct, such as an assignment operator (e.g., "=" in
Java), to link together OOP objects representing business data and
business operations. The object-oriented language construct binds
different OOP objects representing business application objects and
shows and enforces a relationship between them. For example, as
shown in the exemplary implementation of FIG. 7A, the processing
class objects 798 of a wagetype object may be related to processing
class value objects, and these relationship are represented by the
Java assignment operator "=." The processing class object
"WageType_s123.ProcessingClass03," for instance, is linked to the
value of the business object
"processingclasses.ProcessingClass03.Value0" by the equality
operator "=."
[0083] Other business objects may also be linked. For example, a
business rule object may be linked to a wagetype object that it
affects. For instance, as shown in the example of FIG. 27, a
variable object in a rule may be linked to a wagetype processing
class attribute, with that link represented by an assignment
operator.
[0084] Representing the business object relationships as OOP
language constructs, such as an assignment operator like "=,"
allows the use of a OOP language tool, such as a Java debugger, to
walk through referential relationships and discover referential
problems in the integrity of the business application layer. For
example, as shown in FIG. 7A, if the value of
processingclasses.ProcessingClass03.Value0 is not defined, then the
compiler will flag a reference error when it processes the equality
operator in the statement
"WageType_s123.ProcessingClass03=processingclasses.ProcessingClass03.Valu-
e0." Thus, when trying to resolve the assignment operator
relationship, a Java compiler will be able to identify broken links
or references, which represent empty links in the corresponding
modeled business application. Consequently, for an instance of
wagetype, for example, a user can see from the Java code model what
values are acceptable for each processing class. The model also
lists exactly which processing classes are part of the wagetype,
and thus any unlisted processing classes are not defined for that
wagetype (and so not allowed). The assignment operator and
processing classes included in the wagetype OOP structure are
examples of integrity checks for the business application.
[0085] FIG. 8 illustrates an exemplary process consistent with the
invention. As shown, the process may begin by defining
transformation rules for converting logical connections from a
business application into object-oriented structures that represent
the logical connections (stage 810). Next, the process may scan a
business application to identify a logical connection or link
between table-based data structures or between table-based data
structures and rules (stage 820). Next, the process may convert the
identified logical connection or link into an object-oriented
structure, according to the transformation rules (stage 830). In
one embodiment, the transformation rules include using the equality
operator of an OOP language as the object-oriented structure. In
some embodiments, the transformation rules are defined manually
according to criteria similar to that described for transforming
business structures and business rules.
[0086] The process may then determine whether all the logical
connections or links in the business application have been
converted into object-oriented structures (stage 840). It not
(stage 840, No), the process may loop back and continue to identify
and convert logical connections. If so (stage 840, Yes), then the
process may display the object-oriented structures as an
object-oriented programming construct, such as an assignment
operator, between related business data and/or business operation
representations (stage 850).
[0087] In the exemplary embodiment shown, the process may then
identify any problems associated with the object-oriented
structure, such as an unresolved reference or other integrity
problem (stage 860). Such problems may be identified by convention
OOP language tools, such as compilers and linkers. Any such problem
represents a problem in the corresponding business application
structures and relationships, and the OOP language constructs model
the relationships and behaviors of the business application from
which they are derived.
[0088] As with data structures (e.g., configuration data) and
operations (e.g., rules) in business applications, the
relationships or links between the business data and business
operations are typically table-based, making the relationships
difficult, at best, to discern with the table-centric views and
tools provided by a typical business application system. For
example, as illustrated in FIG. 3, the relationships between
configuration data 305 and business rules 310 may not be realized
until runtime, making it difficult for users and administrators to
comprehend, manage, create, revise, and debug such relationships,
especially by working with the static tables before runtime. In
another example, a single business rule may be stored in multiple
tables. To determine all of the configuration data used by such a
business rule, it may be necessary to study all of the multiple
tables storing the rule. This process can be time-consuming and
error-prone, just to understand the relationship between a business
rule and the data on which it operates.
[0089] Embodiments of methods and systems consistent with the
present invention transform business application objects and
relationships into object-oriented programming constructs, making
it possible to display business objects and their relationships in
an easily comprehensible and manageable manner.
[0090] Using processes described above, an object-oriented model
may be generated to represent a table-based business application.
The object-oriented model may represent logical entities of the
business application, such as rules, configuration data, and
schema. The model may also represent links between the logical
entities. In this way, object-oriented tools and graphical user
interfaces may be used to display the links between the logical
entities of the business application.
[0091] For example, as shown in FIG. 31, a user may select a
business object such as an evaluation class, e.g., evaluation class
02, "Wage type assignment for pay statement." This business object
may be chosen from a menu of available evaluation classes, as shown
in the upper center right panel with the tab labeled "Evaluation
Class." By processing the object-oriented model of the business
application using common object-oriented tools and methods, all
business application objects that reference evaluation class 02 may
be determined and displayed. For example, the referencing objects
may be displayed in a list of References, as shown in the bottom
right hand pane with the tab labeled "References." A total number
of referencing objects may be calculated and displayed, such as
"(found 785)" in the bottom right hand pane with the tab labeled
"References."
[0092] Thus, a user may easily see all the business objects that
depend upon or are somehow related to the selected business object
and gain awareness of the scope of objects in the business
application that may be affected by a change to the selected
business object. By using an object-oriented model of the complex,
table-based business application, relationships not previously
understandable may now be easily determined and displayed.
[0093] In another embodiment consistent with the invention, an
outline may be generated and displayed to expose the structure of
business objects within a business application For example, in FIG.
17, a single integrated display shows information pulled from an
R/3 system in a Javadoc displayed in the lower left pane. This
information includes, for example, a name of a business application
object (e.g., payroll.schemas), a use of the business application
object (e.g., "This function retrieves employee health plan benefit
information . . . "), business application syntax for the object
(e.g., Fkt Par1 Par2 Par3 Par4), and an explanation of the
parameters.
[0094] This information may be displayed simultaneously with an
object-oriented model of the business object. In the lower right
pane of the single integrated display shown in FIG. 17, pseudo-Java
code is displayed that represents payroll.schemas as an
object-oriented package. Drop-down lists and pop-up windows may be
displayed with the integrated display to provide more information.
For example, the information from R/3 shown in the lower left-hand
pane may also be shown in a pop-up window over the object-oriented
pseudo-code when a user selects a certain part of the
object-oriented structure.
[0095] In these ways, methods and systems consistent with the
present invention use object-oriented models and tools to determine
and display the relationships between logical entities in a
table-driven business application.
Processing a Model of a Business Application
[0096] The following sections describe exemplary embodiments for
processing a model of a business application. While the description
below provides headings
[0097] Exposing Deprecated Entities
[0098] Business applications often involve large, complex legacy
systems. Over time, these systems evolve to accommodate changing
business rules, user needs, etc. Each change to a business
application may affect many logic entities within the business
application. For example, changing a processing rule may result in
another logic entity, such as configuration data, that is no longer
used by the business application. However, because the business
application is large and complex, the user making the change may be
unaware that the logic entity is now unused and could be deleted.
Instead, the unused logic entity remains in the business
application even though it is never again used.
[0099] As time passes, a business application may develop a great
deal of unused, or "deprecated" logic entities, including
configuration data and processing rules. Traditional table-based
business applications do not have a mechanism for identifying or
removing deprecated logic entities. This results in wasted storage
space and unnecessary programming complexity associated with
conventional business applications.
[0100] Using methods and systems consistent with the present
invention, deprecated logic entities of a business application may
be identified using an object-oriented model of the business
application. By transforming business application structures into
object-oriented structures, deprecated logic entities in the
business application may be exposed using object-oriented
referential integrity checking.
[0101] For example, an object-oriented code compiler checks syntax
and identifies potential problems, such as mixed data types, broken
references, etc. Because a compiler does not actually run the code,
it can be used to analyze an object-oriented model consistent with
the present invention. The potential problems identified by the
compiler in the object-oriented model may correlate to deprecated
logic entities in the business application. These potential
problems may be marked in an integrated configuration environment
to indicate deprecated logic entities that could be removed to
streamline the corresponding business application.
[0102] Each logic entity in a business application may be
transformed into a corresponding object-oriented structure. An
object-oriented compiler may then be used to check the referential
integrity of the object-oriented structures. Although the
object-oriented compiler thinks it is finding problems, such as
broken references, in object-oriented code, it is actually
identifying problems in the underlying business application. For
example, the object-oriented compiler may identify a reference to a
branch of code that will never be executed. By correlating the
identified branch of code with its corresponding logic entity in
the business application, a deprecated logic entity is identified.
In one embodiment, deprecated logic entities may be removed from
the business application after they have been identified using the
object-oriented model.
[0103] In one example, a business application logic entity, such as
"wagetype," may not be defined in the business application for a
certain country such as New Zealand. However, "wagetype" cannot be
deleted from the business application altogether because it is
defined for other countries. During transformation, the
object-oriented structure corresponding to wagetype in New Zealand
may be created but marked as deprecated to indicate that it is
unused in the underlying business application. Deprecated
structures may be marked, for example, using yellow underline in
displayed object-oriented programming language. Yellow might be
used because the deprecated structure is not an error that needs to
be fixed (which might be shown in red). In this way, a user viewing
the object-oriented structure is alerted to deprecated structures
in the business application and can more readily study the effects
of changes.
[0104] FIG. 9 is a flowchart of a method for exposing deprecated
business application logic entities using an object-oriented model.
In this embodiment of the present invention, a model representing
logic entities of the business application is received (step 910).
As discussed above, the model may be, for example, in an OOP
format. The model is processed using a code compiler, such as an
object-oriented code compiler, to identify a possible exception in
the model (step 920). The possible exception in the model is
correlated to an unused logic entity in the business application
(step 930), and an indicator of the possible exception may be
displayed with the model to depict the unused logic entity in the
business application (step 940).
[0105] For example, a code compiler may identify a dead pointer in
an object-oriented model of business application logic entities.
The dead pointer may correlate to an obsolete rule (e.g., a
repealed or expired tax) in the business application. When the
model is displayed in an integrated configuration environment, the
corresponding object-oriented code structure may be underlined or
highlighted or otherwise marked to indicate the deprecated business
application logic entity. Other possible exceptions include
orphans, cost structures that do not exist, outdated regulations,
expired taxes, etc.
[0106] One example of a display consistent with the present
invention may be found in the screen shot shown in FIG. 25. A
business application rule, "W020--Cumulation of gross amount," is
displayed using an object-oriented model in a large window of a
single integrated configuration display. To the right side of the
large window is a series of rectangular flag markers indicating
possible problems identified by a code compiler applied to the
object-oriented model. When the cursor is placed over a flag
marker, a pop-up box may be displayed reading, for example,
"RuleWRFI cannot be resolved." This may indicate to a user that the
business application logic entity corresponding to the
object-oriented model may be deprecated.
[0107] Refactoring
[0108] Modifications made to a business application can make an
already complex system even more unwieldy to understand and
maintain. These difficulties are compounded by the fact that
table-based business applications do not allow the use of design
techniques available in other types of systems. Refactoring is a
programming technique for improving the design of existing software
code without altering the code's behavior. Refactoring may improve
code by, for example, consolidating many statements into one,
decomposing long methods into shorter ones, eliminating
redundancies, etc. Refactored code may be easier to read and
understand, simpler to debug, and more efficient to run and
maintain.
[0109] Systems and methods consistent with the present invention
enable the use of refactoring to reorganize the configuration of a
business application. By transforming business application
structures into object-oriented structures, object-oriented
refactoring tools may be used to retool the underlying business
application.
[0110] Program refactoring tools may be applied to object-oriented
structures to edit the structures without affecting their behavior.
Refactoring may be a recursive process, taking several passes
through a structure or code section in order to optimize and
improve it. Refactoring might be performed on an ongoing basis to
maintain code and structures, or it might be applied for a specific
purpose, such as preparing an application for a major upgrade.
[0111] Using this invention, any number of object-oriented
refactoring tools may be applied to the business application
through application to an object-oriented model of the business
application. These tools might include:
[0112] (1) Rename refactoring: This function enables the renaming
of any package, class, method or variable, and automatically finds
and corrects all references to it. By applying the rename tool to
the object-oriented model, the tables and references in the
underlying business application may be better organized or
named.
[0113] (2) Extract method refactoring: This function analyzes a
selected piece of code and transfers it into a separate method in
order to aid program modularization and break code into manageable
pieces. By applying the extract method tool to the object-oriented
model, the underlying business application may be better organized
and easier for users to understand.
[0114] (3) Inline variable refactoring: This feature replaces all
references of a variable with a declaration expression, then
deletes the older variable text. This can save time and effort when
rearranging code or introducing upgrades, such as new tax laws or
new employees. By applying the inline variable tool, the business
application may be updated with a minimum of potential referencing
errors.
[0115] (4) Clean imports refactoring: This function allows a user
to scan code in order to find and remove unnecessary import
statements. Applying this tool may assist with identifying and
cleaning up superfluous elements in the underlying business
application.
[0116] A skilled artisan will recognize that these and may other
refactoring tools and methodologies may be applied to the
object-oriented structures in order to effectively refactor the
corresponding business application.
[0117] Using methods and systems consistent with the present
invention, each logic entity in a business application may be
transformed into a corresponding object-oriented structure. An
object-oriented refactoring tool may then be used to refactor the
resulting object-oriented structures. The refactoring tool will
improve the object-oriented structures by, for example,
consolidating many statements into one, decomposing long methods
into shorter ones, eliminating redundancies, etc. However, the
operation of the code will not be affected. Once refactoring of the
object-oriented code is completed, the object-oriented code may be
translated back into its corresponding business application logic
structures. In this way, the business application will reflect the
improvements made by refactoring the object-oriented code.
[0118] FIG. 10 is a flowchart showing an exemplary method for
redesigning a business application composed in a first programming
format consistent with an embodiment of the present invention. When
a model representing the business application in a second
programming format is received (step 1010), the model may be
processed using a code refactoring tool in the second programming
format (step 1020). In one example, the first programming format
may be a table-based format, such as R/3, and the second
programming format may be an object-oriented programming format,
such as JAVA.TM..
[0119] Modifications to the model made or suggested by the code
refactoring tool may then be analyzed (step 1030). Modifications
suggested by the code refactoring tool may include, for example,
removing redundant code, renaming variables or methods, breaking
large routines into shorter ones, etc. Each modification may be
analyzed before it is accepted, or modifications may be party or
fully automated. After the modifications are accepted and/or
applied to the object oriented model, the object-oriented code may
be translated back into its corresponding business application
logic structures to propagate the changes into the business
application, thus effectively refactoring the business application
itself. In this way, refactoring modifications may be applied, in
the first programming format, to the business application (step
1040).
[0120] In one example, the code refactoring tool includes removing
redundant code of the model in order to remove redundant code in
the corresponding business application. In another example, the
code refactoring tool includes consolidating many statements into
one, which may in turn streamline the corresponding business
application. In yet another example, the code refactoring tool
includes decomposing long methods into shorter ones, making the
corresponding business application easier to understand and work
with.
[0121] Runtime Errors
[0122] Given the complexity of a business application, each change
made to it may affect many logic entities within the business
application, resulting in errors that may not be apparent until
runtime. For example, changing configuration data related to a
project may result in a call to a processing rule that does not
exist for that project. However, because the business application
is large and complex, the user making the change may be unaware
that the call will result in an error during configuration.
Instead, the user may not realize the error until runtime, when it
is costly and time-consuming to correct. Traditional table-based
business applications do not have any simple mechanism for
identifying or removing runtime errors at design time.
[0123] Using methods and systems consistent with the present
invention, runtime errors in a business application may be
identified prior to runtime using an object-oriented model of the
business application. By transforming business application
structures into object-oriented structures, runtime errors (such as
unresolved references) in the business application may be exposed
using object-oriented referential integrity checking.
[0124] Each logic entity in a business application may be
transformed into a corresponding object-oriented structure. An
object-oriented compiler or debugger may then be used to identify
errors, such as syntax errors or broken references, in the
object-oriented structures. Although the object-oriented compiler
thinks it is finding problems in object-oriented code, it is
actually identifying problems in the underlying business
application. For example, the object-oriented debugger may identify
a reference to a branch of code that does not exist. By correlating
the identified branch of code with its corresponding logic entity
in the business application, a problem with dependencies in between
business application structures may be identified. In one
embodiment, a user may correct the problems in the object-oriented
code and translate the corrections back to the business application
before running the business application.
[0125] A runtime error in the business application may be, for
example, calling a rule that does not exist for a project, such as
a country, or attempting to create a wagetype that does not exist
for a project, such as a country. In one embodiment, when business
application structures are transformed into object-oriented
structures, a referential error might be revealed by a class that
is declared but empty. These errors, once identified using the
object-oriented model, may be displayed using, for example, red
underline to show that runtime errors will occur in the business
application. The identifier may be propagated up through a number
of user interfaces to show potential problems at any level of the
system.
[0126] A sample screen shot of how potential errors may be
displayed is included in FIG. 29. In the integrated configuration
environment of FIG. 29, a business application rule,
"W020--Cumulation of gross amount," is displayed for project
USA.ma.800 using an object-oriented model in a large window. To the
right side of the large window is a series of rectangular flag
markers indicating possible problems identified by a code debugger
applied to the object-oriented model. When the cursor is placed
over a flag marker, a pop-up box may be displayed reading, for
example, "RuleWRFI cannot be resolved." This may indicate to a user
that the business application logic entity corresponding to the
object-oriented model has a potential runtime error. The display
also includes a list of problems (e.g., "Rule 9112 cannot be
resolved") in the lower right portion. The problems may be further
displayed up the hierarchy of menus using, e.g., a red "X" to show
the problem in the list of Payroll Rules, the list of logic
entities within project USA.ma.800, and the list of all projects.
By propagating the error flag up the menu hierarchy, users may be
alerted of many potential runtime errors quickly and
effectively.
[0127] In traditional table-based business applications, a log file
may be created to trace the path of processing during a sample run
(e.g., a payroll run) of the business application. The log file may
note errors present in the business application. However, the log
file is typically long and difficult to debug. By using
object-oriented programming constructs, debugging is greatly
simplified. The sequential view of a log file is replaced by an
object-oriented data representation view that is familiar to
developers today. In this way, the same data used for debugging may
be presented in a much more user-friendly fashion. In one
embodiment, the debugging may be performed offline, increasing
efficiency and flexibility of maintaining the business
application.
[0128] FIG. 11 is a flowchart for a process for analyzing
referential integrity of a business application consistent with
embodiments of the present invention. A model representing the
business application may be received (step 1110) and processed
using a code compiler to identify a compiler exception (step 1120).
The compiler exception may be, for example, a broken reference, an
infinite loop, etc. The compiler exception in the model may be
correlated to a referential integrity instance in the business
application (step 1130), and correction of the compiler exception
in the model may be enabled (step 1140). Correction may be enabled
through displaying flags or other indicators to call the problems
to the user's attention and providing configuration tools via an
integrated configuration environment. Finally, the correction to
the business application is applied to correct the correlated
referential instance (step 1150).
[0129] One skilled in the art will recognize that many different
object-oriented code analyzers, including debuggers, interpreters,
compilers, etc. may be used to identify possible runtime errors in
the business application and that many different ways of marking
and correcting these errors may be employed consistent with
embodiments of the present invention.
[0130] Interactive Development Environment (IDE)
[0131] Business applications, such as the R/3 system created by
SAP, often involve large, table-based systems and evolve over many
years as businesses grow and change. Highly trained consultants may
be employed to implement, configure, and maintain a business
application for a company. Due to the complexity of traditional
business applications, it may take years to configure an
application for a single company. Because of their legacy nature
and highly customized usage, business applications typically have
limited development tools to assist in the configuration and
maintenance of the applications.
[0132] To assist in the configuration and management of such
business applications, systems and methods consistent with the
present invention enable business application consultants to
configure and maintain business applications using an interactive
configuration environment that offers the simplicity and usability
of an IDE.
[0133] An IDE is a set of tools available to assist a software
developer in writing and maintaining software code. IDEs enable
users to design and manipulate code, such as object-oriented code,
in an easy-to-understand manner. An IDE may include multiple
programs that are run from a single user interface. For example,
programming languages often include a text editor, compiler and
debugger, which are all activated and function from a common menu.
Other IDE tools may include a version control system, GUI design
tools, a class browser, an object inspector, and a class hierarchy
diagram. IDEs are available for specific programming languages,
e.g., the Visual Basic IDE, or for multiple languages, e.g., the
Eclipse IDE.
[0134] An interactive configuration environment consistent with the
present invention integrates and displays a table-based business
application using a single, interactive display. For example, users
can write a new business rule using familiar object-oriented code,
and that code may be converted into logic entities to apply the new
rule in the business application. In another example, users may
view existing business applications using an IDE interface. In this
way, users may not need to worry about the format or structure of
the business application but may still be able to understand and
configure it.
[0135] When business application structures are displayed using
object-oriented code structures, the business meaning of the
object-oriented code structures may also be displayed in the
integrated environment. For example, when a user rolls a mouse over
an item in the object-oriented code, documentation of the
underlying business meaning may be displayed in a pop-up box. This
aids the user in understanding a complex business application using
familiar, easy-to-understand object-oriented programming
constructs.
[0136] Using an object-oriented user interface, the user may browse
business application logic entities and related objects using a
single integrated display. Object-oriented code assists and
templates may be available to assist users in writing new
object-oriented code in order to add new logic entities to the
business application. A template may consult a translation key to
determine syntax, parameters, etc. and display these options in a
drop-down list in the object-oriented code display. Using IDE
tools, a state of the business application may be compared with a
changed state of the business application, for example, by using a
side-by-side display.
[0137] FIG. 12 is an exemplary flowchart of a method for analyzing
the configuration of a business application consistent with
embodiments of the present invention. When a model representing the
business application is received (step 1210), the model may be
displayed using a developer interface (step 1220). The model and
corresponding business application may be integrated and displayed
using a single, dynamic display, e.g., the integrated configuration
environment shown in FIG. 17. The integrated configuration
environment may include, for example, a series of windows
displaying business application entities as a hierarchy of
projects, rules, and schema. The environment may also include an
object-oriented model of a business application object displayed
together with documentation pulled from the business
application.
[0138] When a change to the model is received through the developer
interface (step 1230), the change to the model may be correlated to
a corresponding configuration change in the business application
(step 1240). The corresponding configuration change may be applied
to the business application or it may simply be used to model
possible changes.
[0139] For example, a consultant may wish to modify a rule in the
business application. Rather than analyzing the table-based
structure of the business application to determine the tables that
hold different parts of the rule, the consultant may use the
integrated configuration environment to edit the rule using its
object-oriented model counterpart. As part of the integrated
configuration environment, the proper syntax or available
parameters may be automatically displayed to assist the consultant
in making his edits. Once the edit is complete in the
object-oriented model, the change may be translated back to the
underlying business application and automatically applied, e.g., to
the many tables that hold different parts of the rule.
[0140] In another example, a consultant may wish merely to
determine the effects that a potential change to the business
application would have. Using an object-oriented model of the
business application, the consultant could try out the potential
change by applying it in the integrated configuration environment
to see what the effects would be if the change were committed back
to the business application.
[0141] A skilled artisan will appreciate that many other
configuration tools would be made available to users of a business
application by displaying and manipulating an object-oriented model
of the business application using an integrated configuration
environment consistent with the present invention.
[0142] Checking Validity of Business Applications
[0143] As described above, business applications often involve
large, complex legacy systems. Over time, these systems evolve to
accommodate changing business rules, user needs, etc. Each change
to a business application may affect many logic entities within the
business application. Furthermore, changes to the business
application can make an already complex system even more difficult
to maintain. These difficulties are compounded by the fact that
table-based business applications do not allow the use of design
and optimization techniques available in other types of
systems.
[0144] For example, changing a processing rule may result in
another logic entity, such as configuration data, being
inconsistent with underlying business logic. However, because
business applications are large and complex, the user making the
change may be unaware that the logic entity now contains a logic
structure error. Traditional table-based business applications do
not have a mechanism for identifying or optimizing inconsistencies
in underlying business logic. Thus, many problems, such as broken
or circular links in logic entities, may be undetected in the
business application.
[0145] A number of well-known programming techniques may be used to
optimize the design of existing software code without altering the
code's behavior. For example, a software debugger, such as Validity
Check, True Time, or Bounce Checker may improve code by testing it
and modifying the values of variables where necessary. Optimized
code is generally easier to read and understand and more efficient
to maintain.
[0146] Methods and systems consistent with the present invention
enable the use of known software tools, such as debuggers, to
optimize the configuration of a business application by eliminating
inconsistencies in underlying business logic of the business
application. In one embodiment, each logic entity in a business
application may be transformed into a corresponding object-oriented
structure. An object-oriented language tool, such as a compiler,
may then be used to check the structural consistency of the
object-oriented structures and flag identified logic structure
errors. Although the object-oriented language tool literally
identifies problems, such as broken links, in object-oriented code,
it also identifies problems in the underlying logic of a business
application because the code models the business application. For
example, an object-oriented compiler may identify a circular
reference within a branch of code. By correlating that branch of
code with its corresponding logic entity in the business
application, the inconsistent logic entity may be identified. In
one embodiment, inconsistent logic entities in the business
application may be corrected after they have been identified using
the object-oriented model, and the model translated back into
business application entities that will function in the business
application system.
[0147] For example, a debugging tool will optimize the
object-oriented structures, for example, by "repairing" circular
links. However, the operation of the code will not be affected.
Once correction of identified logic structure errors in the
object-oriented code is completed, the object-oriented code may be
translated into corresponding business application logic
structures. As a result, the business application will reflect the
improvements made by optimizing the object-oriented code.
[0148] In one method consistent with the present invention shown in
FIG. 13, a business application composed in a first programming
format may be analyzed by receiving a model representing the
business application in a second programming format (stage 1310)
and processed by using a code optimization tool to identify logic
structure errors (stage 1320). Identified logic structure errors
may then be corrected (stage 1330) and applied in the first
programming format, to the business application (stage 1340).
[0149] Using CASE Tools to Verify Business Application
[0150] As described above, business applications often involve
large and very complex table-based systems. To configure and
implement a business application, a company may need to employ
highly trained consultants. Due to the complexity of traditional
business applications, it may take years to configure an
application for a single company. Business applications typically
have limited range of development tools to assist in development of
the business applications configuration.
[0151] Computer-aided software engineering (CASE) tools assist a
software developer in developing and maintaining software code.
CASE tools enable users to design and manipulate code, such as
object-oriented code, in an easy-to-understand manner. For example,
data dictionaries and diagramming tools aid developers in analyzing
and designing software systems. In another example, application
generators may assist in actual programming of a system. Other CASE
tools may assist with data modeling, reverse engineering,
simulations, etc. Though CASE tools are available to assist
programmers in analyzing and designing traditional software
systems, such generic tools are not capable of being applied to a
large, legacy system that might be customized to suit the needs of
a single company.
[0152] Systems and methods consistent with the present invention
enable the use of CASE tools to analyze and verify the
configuration of a business application. By transforming business
application structures into object-oriented structures,
object-oriented CASE tools may be used to verify the underlying
business application configuration. For example,
CASE-tool-generated diagrams representing business application
layers may assist an architect of a business application in
visualizing a matrix of a project. As a result, the architect of a
business application may more efficiently design and optimize a
business process. For example, such diagrams may help a user to
identify an amount of wagetypes, and how those wagetypes are
related. In another example, simulation or modeling CASE tools may
be used to test the effects of potential configuration changes in a
business application. In this way, CASE tools could be applied to
assist a consultant in configuring a business application or
verifying an existing business application configuration.
[0153] Systems and methods consistent with the present invention
enable business application consultants to generate and analyze the
structure of business applications using tools from a CASE
environment. For example, a developer may use a Modified Modeling
Language (MML) tool to build a high level diagram of a logic
entity, such as a business object class.
[0154] By transforming business application structures into
object-oriented structures, object-oriented CASE tools may be
applied to generate similar business application structures. For
example, a user can write a new business rule using familiar
object-oriented code, and that code may be converted into logic
business entities to apply the new rule in the business
application. As a result, users may configure the business
application without worrying about its native format or
structure.
[0155] In some embodiments, when business application structures
are displayed using object-oriented code structures, the business
meaning of the object-oriented code structures may also be
displayed. This aids the user in understanding a complex business
application in the format of familiar, easy-to-understand
object-oriented programming constructs.
[0156] FIG. 14 is an exemplary flowchart of a process for analyzing
and verifying an application configuration using CASE tools. In
certain embodiments consistent with the present invention, a
business application composed in a first programming format is
analyzed by receiving a model representing the business application
in a second programming format (step 1410). The first programming
format may be, for example, a table-based format, and the second
programming format may be, for example, an object oriented
programming format. The model is then processed using CASE tools to
generate its structure, including, for example, the structure of
the business application configuration data and rules (step 1420).
In another example, processing may include generating a diagram of
the model's object classes which represent logic entities within
the business application. The generated structure of the model may
be analyzed to depict a structure of the business application (step
1430).
[0157] In certain embodiments, a table-based business application
is represented by an object-oriented programming model. Because the
model appears to contain object-oriented code statements,
traditional CASE tools may be applied to it for a number of
purposes, such as designing new structures (e.g., business
application rules), testing proposed changes (e.g., a new tax
category in the business application), and simulating a business
application run (e.g., an end-of-month payroll run in the business
application). Once these CASE tools have been applied to the
object-oriented model, the results can be applied back to the
business application to make appropriate modifications to the
business application.
[0158] Comparing and Merging Business Applications
[0159] Large, complex legacy systems require almost constant
updating and maintenance to keep up with the changing business
environment. These changes may include, for example, software
patches fixing technical glitches or improving the usability or the
performance of a business application; new code to support changing
business rules or evolving user needs, etc. For example, changing
tax laws in one of the countries in a payroll business application
may require changing many business rules within the application.
Each change to a business application may affect many logic
entities within the business application, possibly changing an
outcome, for example, an amount of calculated payroll.
[0160] Traditional table-based business applications do not have
any simple mechanism for modeling changes or identifying changes
between different versions of a business application. A user
attempting to compare two different versions of a business
application and identify, for example, different tables or
differences in a code, would have to compare each business rule
separately, one by one. Because the business application is large
and complex, this process may be extremely time-consuming and
require a user with extensive training. Even then, small but
important changes may be hard to recognize in a large table-based
application.
[0161] Methods and systems consistent with the present invention
allow a user to compare different versions of a business
application using an object-oriented model of the business
application. By transforming business application structures into
object-oriented structures, such as object-oriented language
constructs, individual differences between versions of the business
applications may be identified and displayed to a user, for
example, on a user interface.
[0162] To aid users in identifying differences between different
versions of a business application, multiple versions of a business
application configuration may be stored in a database, such as a
configuration control database like CVS. Each version of a business
application may be stored in a configuration control database as a
transformed corresponding object-oriented structure.
[0163] Using methods and systems consistent with the present
invention, to compare an updated version of the configuration of a
business application with its previous versions, a user may extract
the latest control version of an object-oriented model of the
application from a configuration control database. Then, a user may
extract the latest deployed version of a business application from
a server database containing the deployed version of the business
application, including recent updates, such as, for example,
patches. The extracted deployed version may be transformed into a
corresponding object-oriented structure. Finally, the user may
extract a version of the business application including user-made
current changes from the user's storage space. The object-oriented
models of the business application may be capable of autonomous
existence from the business application. Having all three versions
represented in an object-oriented structure may allow a user to
perform a three-way comparison between the object-oriented
structure edited by the user and two retrieved versions copied from
the configuration control database and the deployed server
database.
[0164] Using methods and systems consistent with the present
invention, a user may automatically compare all three versions of
the business application model in a visually enabled mode by, for
example, selecting a "Show Changes" button. As a result, business
objects, for example, wage types, that differ between the three
configurations may be displayed on an user interface marked with an
icon to show where changes have been made. In one example, an icon
may be shown to highlight each change and list values of the
business object before and after the change.
[0165] Comparing the object-oriented structures of the model's
three different versions, object-by-object, may allow a user to
identify, for example, configuration data (e.g., wagetypes),
business rules, schemas, and other logic entities where changes
have been made. In each instance, a user may choose a value of the
business object for preservation and subsequent storage as a new
version of the business application model. Thus, as a result of the
three-way comparison, a new version of the object-oriented
structure may be created containing a user's chosen values for each
business object.
[0166] When a user completes the three-way comparison and decision
process, the newly-created version of the object-oriented model may
be transformed into a newest version of the business application.
That version may also be tagged as the "latest" and forwarded to a
configuration control database for storage and/or to a target
business system for deployment.
[0167] FIG. 15 is a flowchart of a process for comparing and
merging versions of a business application using methods consistent
with the present invention. A current version of a business
application is determined by receiving a first version, a second
version, and a third version of an object-oriented programming
model representing the business application (stage 1510). The
objects of each of the first, the second, and the third versions of
the object-oriented programming model are compared (stage 1520) to
identify differences between any objects in these models (stage
1530). For each identified difference, a determination is made as
to which version of the model is to be associated with the first
version of the object-oriented model (stage 1540). The first
version of the object-oriented model is then assigned as the
current version of the model (step 1550). Using methods and systems
consistent with the invention, the current version of the model may
be translated back into the business application format, thus
creating a current version of the business application.
Customer Support
[0168] As described above, OOP language tools, such as compilers,
analyzers, optimizers, etc. can be used to find errors or problems
in the configuration model of a business applications. Such errors
or problems may include errors in relationships, calls,
interactions, design, etc. associated with the modeled null
functions.
[0169] FIG. 16 is a flowchart of an exemplary process consistent
with the present invention. As shown in FIG. 16, a model
representing the business application composed in a second
programming format is processed (stage 1610). Systems consistent
with the invention may then determine, based on the processed
model, a potential problem in the business application (stage 1620)
and identify the determined potential problem by displaying a
marker in the model of the business application (stage 1630). In
exemplary embodiments, the marker may be displayed in the model at
a location where the potential problem occurs. Furthermore, the
displayed marker may be associated with information describing the
determined potential problem.
User Interfaces
[0170] FIGS. 17 to 56 illustrate exemplary user interfaces
consistent with the invention for enabling a user to process a
model representing a business application, as described above with
respect to FIGS. 1 to 16.
[0171] Consistent with methods and systems of the invention, a user
interface displaying all the relevant information on one graphical
and productive screen may be used. As shown in FIGS. 17 to 56, user
interfaces consistent with the invention may enable a user to
easily navigate within an object-oriented structure from one object
to another. The user interface may provide an instant visual alert
of a potential problem, for example, with a source code. The user
interface may also provide an intelligent code assistance and
wizards. For example, all the references to a selected object, such
as a schema or a rule, may be instantly displayed facilitating an
instant dependency analysis. In another example, a user interface
may have superior error detection and reporting capabilities, such
as instantly reporting errors or enabling a user to find an exact
error location just after one click.
[0172] Consistent with methods and systems of the invention, a user
interface shown in FIG. 17 illustrates auto-complete capabilities
in an Integrated Configuration Editor (ICE) environment. As shown
in FIG. 17, the user interface may list all the business objects
and provides documentation for each of them. The user interfaces
may depict grouping of the projects in ICE environment. The
integrated configuration environment may include, for example, a
series of windows displaying business application entities as a
hierarchy of projects, rules, and schema, The environment may also
include an object-oriented model of a business application object
displayed together with documentation pulled from the business
application.
[0173] For example, FIG. 18 depicts grouping of the projects
defined by a country, and FIGS. 19 and 20 depict grouping of the
projects defined by a system and a client, respectively, which has
the least possible amount of attributes allowing to enforce
uniqueness for all managed objects within a project. For example,
using three attributes as the minimum set of attributes to define
uniqueness, as shown in FIG. 19, may allow the system to rearrange
attributes and build hierarchies with better workspace
organization. The user interface shown in FIG. 20 may depict a
linear project layout when all key attributes are shown in a
project name. A little block with a cross inside appearing next to
a project type may indicate an existing potential problem or an
error. For example, a block next to Germany on FIG. 18, may
indicate that an error in object "Germany" exists.
[0174] Consistent with methods and systems of the invention, a user
interface shown in FIG. 21 may depict an offline debugger or log
replay. Having an ability to see this screen may allow a user to
look at dynamic and static views of payroll tables, full view of
payroll steps, a source code displayed at a current execution
point, and debugging controls.
[0175] Consistent with methods and systems of the invention, a user
interface shown in FIG. 22 may depict inter object relationships
within a project. For example, a user highlighting processing class
with value M003, such as salary wage type, may result in displaying
different rules referenced to that wage type.
[0176] Consistent with methods and systems of the invention, a user
interface shown in FIG. 23 may depict one or more problems or
errors encountered when business application structures are
transformed into object-oriented structures. If during the
conversion an error occurred, the error may be marked as a task for
the user to fix. For example, if the user typed in an invalid
syntax in a "RuleDPPF.java" module, a task of "Empty code" is
listed for the user to fix along with a complete description of the
error, which in this example is that "RuleDPP1 cannot be
resolved."
[0177] Consistent with methods and systems of the invention, a user
interface shown in FIG. 24 may depict, in greater detail, one or
more problems, or errors, encountered when business application
structures are transformed into object-oriented structures. If in
FIG. 23 a user double clicks on a error, the schema where the
problem exists is displayed for the user and the portion of the
schema with the error is highlighted. When a cursor is placed above
the marker, a pop-up box may show the details of the error. For
example, the user may be notified that the method P0171 is
undefined.
[0178] Consistent with methods and systems of the invention, a user
interface shown in FIG. 25 may depict all the errors encountered in
when business application structures are transformed into
object-oriented structures. Each error may be indicated by a marker
(here a rectangular flag) on the far right of the user interface
identified by a code debugger applied to the object-oriented model.
When a cursor is placed above the marker, a pop-up box may show the
details of the error, and a click on the marker takes the user to
the exact location of the error within the schema. For example, in
the schema "RuleW020.java," errors are indicated by the marker on
the right side of the screen. If a user places a cursor above the
marker indicating the error, the details of the error "RuleWRFI
cannot be resolved" is shown.
[0179] Consistent with methods and systems of the invention, a user
interface shown in FIG. 26 may depict one or more warnings
encountered when business application structures are transformed
into object-oriented structures. A warning may consist of informing
a user that a part of a module may be referencing a rule or value
that is no longer used by the system. The warning is not an error
and will not stop the conversion of the R3 structures to the Java
structures. For example, if within a module a variant is checked to
determine whether it equals a certain value, i.e.,
"processingclasses.ProcessingClasses04.Value8," the system may
inform the user that "The field ProcessingClass04.Value8 is
deprecated," in other words, ProcessingClass04.Value8 may not exist
or is no longer used within the system.
[0180] Consistent with methods and systems of the invention, a user
interface shown in FIG. 27 may also depict a problem, or error
encountered when business application structures are transformed
into object-oriented structures. The error is marked as a task for
the user to fix with a description being given under the "Problems"
tab. For example, the error of "empty code" is listed as a task for
the user in the module "RuleDPPF.java" and the description of the
error is that "Rule9112 cannot be resolved." Rule9112 may also be
highlighted in the user interface.
[0181] Consistent with methods and systems of the invention, a user
interface shown in FIG. 28 may further illustrate details
associated with a problem, or error encountered when business
application structures are transformed into object-oriented
structures where a rule in the transformation may not produce any
result. For example, if the user clicks on the description of the
error, the user may be directed to the portion of the
"RuleDPPF.java" schema where the error occurred. In this example, a
variable "variant" is set equal to nothing; therefore the user may
have to enter a value to resolve the error.
[0182] Consistent with methods and systems of the invention, a user
interface shown in FIG. 29 may also depict all the problems or
errors when business application structures are transformed into
object-oriented structures in one view. Each errors may be
indicated by a marker on the far right of the user interface. When
a cursor is placed above the marker, a pop-up box may show the
details of the error. If a user clicks on the marker, the user is
taken to the exact location of the error within the schema. For
example, in the schema "RuleW020.java," there are problems
indicated by the marker on the right side of the screen. If a user
places a cursor above the marker indicating the problem, the
details of the problem "RuleWRFI cannot be resolved" is shown.
[0183] Consistent with methods and systems of the invention, a user
interface shown in FIG. 30 may depict the object-oriented structure
that has encountered an error during the transformation of the
business application structures into the object-oriented
structures, and give a description of the error.
[0184] Consistent with methods and systems of the invention, a user
interface shown in FIG. 31 may depict one or more evaluation
classes within a project. A user may select an evaluation class
business object, such as evaluation class 02, "Wage type assignment
for pay statement," as shown in the upper center right pane with
the tab labeled "Evaluation class." By processing the OOP object
model of the business application using common OOP tools and
methods, the system finds and displays all the business objects
that are related to or reference the selected "Wage type assignment
for pay statement" evaluation class 02 object, as shown in the
bottom right hand pane with the tab labeled "References."
[0185] Consistent with methods and systems of the invention, a user
interface shown in FIG. 32 may depict an Evaluation class within a
project in an R/3 view.
[0186] Consistent with methods and systems of the invention, a user
interface shown in FIG. 33 may depict the specifications for an
evaluation class business object such as an Evaluations class
within a project in an R/3 view. For example, a user interface may
depict the specifications of Evaluations class "Wage type
assignment for payroll account."
[0187] Consistent with methods and systems of the invention, a user
interface shown in FIG. 34 may depict a screen where one or more
operations are defined for one or more countries in an R/3 view.
For example, the operation "ADDW Add wage type to subsequent wage
type" may be defined for Canada, China, Denmark, Finland, France,
Germany, and Great Britain. FIG. 35 is another user interface
consistent with an embodiment of the invention.
[0188] Consistent with methods and systems of the invention, a user
interface shown in FIG. 36 may depict one or more processing
classes within a project, and the various operations that can be
performed on each processing class is also depicted. For example,
the processing class "Cumulation and storage at end of gross part"
is shown in the user interface, and with a right click on that
processing a menu is shown where a user may choose from one of many
options such as "Copy Processing Class."
[0189] Consistent with methods and systems of the invention, a user
interface shown in FIG. 37 may depict a Processing class within a
project in an R/3 view.
[0190] Consistent with methods and systems of the invention, a user
interface shown in FIG. 38 may depict the specifications for a
Processing class within a project in an R/3 view. For example, a
user interface may depict the specifications of Processing class
"Cumulation and storage of time wage types."
[0191] Consistent with methods and systems of the invention, a user
interface shown in FIG. 39 may depict an R/3 outline view of a rule
representation along with the converted object-oriented code. For
example, for the Payroll Rule "X015--Valuation of time wage types"
the business application outline is on the left hand side of the
screen and the middle of the screen shows the converted
object-oriented code for the same rule.
[0192] Consistent with methods and systems of the invention, a user
interface shown in FIG. 40 may depict an object-oriented outline
view of a rule representation along with the object-oriented code.
For example, the object-oriented outline of the rule "$401--Store
excess amount from pre-tax 4-01 K to after-tax 401-K" is shown on
the left side with the converted object-oriented code for the same
rule is in the middle of the screen.
[0193] Consistent with methods and systems of the invention, a user
interface shown in FIG. 41 may depict a rule in a business
application view. For example, the rule "X013 Es Grouping" is
depicted as an R/3 business application.
[0194] Consistent with methods and systems of the invention, a user
interface shown in FIG. 42 may depict a table instance of the rule
in a business application view. For example, a table instance of
the rule "U013" is depicted as an R/3 data structure.
[0195] Consistent with methods and systems of the invention, a user
interface shown in FIG. 43 may depict an R/3 data structure schema,
the object-oriented code of that schema, and the various references
where the schema is used. For example, the schema
"$APO--reoccurring benefits/Deductions and one time payments" is
depicted along with the references that use the schema, which are
"US00--Payroll Calculation" and "$US0--Payroll Calculation."
[0196] Consistent with methods and systems of the invention, a user
interface shown in FIG. 44 may depict a function within an R/3 data
structure schema, the implementation of the function, and other
schemas where the function is used. For example, the function
"P0377" may be shown along with the implementation of the function
in the middle of the screen and the bottom right may show other
schemas (ex: "BRB2," "BGE2," etc.) that use the function
"P0337."
[0197] Consistent with methods and systems of the invention, a user
interface shown in FIG. 45 may depict a table within a project and
all the rules that use that table. For example, the table "Output
table" is depicted and under "References," all the payroll rules
that use the "Output table" are listed.
[0198] Consistent with methods and systems of the invention, a user
interface shown in FIG. 46 may depict the object-oriented
representation of R/3 data structure features shown in FIGS.
47-52.
[0199] Consistent with methods and systems of the invention, a user
interface shown in FIG. 53 may depict a wage type of a project. For
example, the wage type "M003-Salary" may be displayed to the user.
The references at the bottom of the interface may show others
schemas that use this particular wage type within the same
project.
[0200] Consistent with methods and systems of the invention, a user
interface shown in FIG. 54 may depict another example of a wage
type of a project. For example, the wage type "1055--Premium Pay"
may be displayed to the user. The references at the bottom of the
interface may show other schemas that use this particular wage
type.
[0201] Consistent with methods and systems of the invention, a user
interface shown in FIG. 55 may show an object-oriented version of
the R/3 data stucture "Wage type group" as shown in FIG. 56. Each
wage type group may have one or more wage types associated with it.
For example, the wage type group "0008 Basic Pay" may be associated
with the wave types "SJ00 JS Hourly Wage, "2J20 JS Perfect perf
bonus," etc.
CONCLUSION
[0202] Accordingly, as disclosed, systems and methods are provided
for analyzing a business application's data, operations, and
relationships and creating a corresponding object oriented
programming (OOP) object model, comprising OOP objects, functions,
and operators corresponding to the business application entities,
and various uses involving the OOP model for improving the business
application. The foregoing description of possible implementations
consistent with the present invention does not represent a
comprehensive list of all such implementations or all variations of
the implementations described. The description of only some
implementations should not be construed as an intent to exclude
other implementations. One of ordinary skill in the art will
understand how to implement the invention in the appended claims in
may other ways, using equivalents and alternatives that do not
depart from the scope of the following claims.
[0203] The systems and methods disclosed herein may be embodied in
various forms including, for example, a data processor, such as a
computer that also includes a database. Moreover, the above-noted
features and other aspects and principles of the present invention
may be implemented in various environments. Such environments and
related applications may be specially constructed for performing
the various processes and operations according to the invention or
they may include a general-purpose computer or computing platform
selectively activated or reconfigured by code to provide the
necessary functionality. The processes disclosed herein are not
inherently related to any particular computer or other apparatus,
and may be implemented by a suitable combination of hardware,
software, and/or firmware. For example, various general-purpose
machines may be used with programs written in accordance with
teachings of the invention, or it may be more convenient to
construct a specialized apparatus or system to perform the required
methods and techniques.
[0204] Systems and methods consistent with the present invention
also include computer readable media that include program
instruction or code for performing various computer-implemented
operations based on the methods and processes of the invention. The
media and program instructions may be those specially designed and
constructed for the purposes of the invention, or they may be of
the kind well known and available to those having skill in the
computer software arts. Examples of program instructions include,
for example, machine code, such as produced by a compiler, and
files containing a high level code that can be executed by the
computer using an interpreter.
* * * * *