Back to EveryPatent.com
United States Patent |
5,764,988
|
Govindaraj
|
June 9, 1998
|
System and method for constructing dialogs for commands and templates
Abstract
Described herein is a system and method for facilitating the construction
of computer programs. The system enables an administrator to define
dialogs associated with commands from a computer programming language.
Users construct computer programs by using the dialogs. In particular, an
user invokes a dialog. Code corresponding to a command associated with the
invoked dialog is then automatically generated. The code is in a form and
has a syntax defined by the computer programming language. The code is
inserted into the computer program being constructed. Computer programs
can also be constructed using dialogs and objects. In particular, a
plurality of objects each corresponding to a resource in a target
environment are defined and instantiated from a plurality of object
classes. At least one of the dialogs is associated with each of the
objects. An operator selects one or more of the objects (representing the
resources in a system), and invokes a dialog associated with the selected
objects. The system generates code that, when executed, applies a command
associated with the invoked dialog to each of the selected objects. The
code is in a form and has a syntax defined by the computer programming
language. This code is inserted in the computer program being constructed.
Inventors:
|
Govindaraj; Naresh K. (San Jose, CA)
|
Assignee:
|
International Business Machines Corporation (Armonk, NY)
|
Appl. No.:
|
464534 |
Filed:
|
June 5, 1995 |
Intern'l Class: |
G06F 009/45 |
Field of Search: |
395/700,701,702,705,326,333,334
|
References Cited
U.S. Patent Documents
4742467 | May., 1988 | Messerich et al. | 395/700.
|
4845665 | Jul., 1989 | Heath et al. | 364/900.
|
4860204 | Aug., 1989 | Gendron et al. | 395/700.
|
5202828 | Apr., 1993 | Vertelney et al. | 364/419.
|
5295222 | Mar., 1994 | Wadhwa et al. | 395/700.
|
5341478 | Aug., 1994 | Travis, Jr. et al. | 395/700.
|
5388203 | Feb., 1995 | Kaneko | 395/159.
|
5404441 | Apr., 1995 | Satoyama | 395/334.
|
5465362 | Nov., 1995 | Orton et al. | 395/700.
|
5481712 | Jan., 1996 | Silver et al. | 395/701.
|
5481718 | Jan., 1996 | Ryu et al. | 395/700.
|
5517606 | May., 1996 | Matheny et al. | 395/156.
|
5530864 | Jun., 1996 | Matheny et al. | 395/700.
|
5537630 | Jul., 1996 | Berry et al. | 395/155.
|
5542024 | Jul., 1996 | Balint et al. | 395/161.
|
5555365 | Sep., 1996 | Selby et al. | 395/159.
|
5555370 | Sep., 1996 | Li et al. | 395/334.
|
5559946 | Sep., 1996 | Porter | 395/157.
|
Other References
Data Communications Technical Reference, TR 54022, "AT&T Intelligent Call
Processing (ICP) Service Signaling System No. 7 Network Interface
Specification," Nov. 1991.
"Reference Vol. I, Class Library Reference for the Microsoft Foundation
Class Library," Microsoft Visual C++, Microsoft Corporation, Copyright
1993, pp. 95-120 and 328-337.
|
Primary Examiner: Trammell; James P.
Assistant Examiner: Corcoran, III; Peter J.
Attorney, Agent or Firm: Sterne, Kessler, Goldstein & Fox
Parent Case Text
CROSS-REFERENCE TO OTHER APPLICATIONS
The following applications of common assignee contain some common
disclosure, and are believed to have an effective filing date identical
with that of the present application.
"A Computer Program Product For Enabling the Construction of Dialogs for
Commands and Templates," Attorney Docket 1252.2190000, incorporated herein
by reference.
"System and Method for Constructing Computer Programs Using Dialogs and
Objects," Attorney Docket No. ST9-95-006 (1252.2080000), incorporated
herein by reference.
"A Computer Program Product for Enabling the Construction of Computer
Programs Using Dialogs and Objects," Attorney Docket No. 1252.2180000,
incorporated herein by reference.
Claims
What is claimed is:
1. A method of constructing a computer program, comprising the steps of:
(1) defining one or more dialogs each associated with at least one command
from a computer programming language, wherein said at least one command
when executed in a computer causes the computer to perform a particular
fiction associated with said at least one command, wherein said dialogs
are invoked by an operator wishing to construct a computer program;
(2) invoking one of said dialogs;
(3) generating code corresponding to a command associated with said invoked
dialog, said code being in a form and having a syntax defined by said
computer programming language; and
(4) inserting said code into the computer program being constructed by said
operator;
wherein step (1) comprises the following steps that are performed for each
dialog being defined;
(a) providing a command string specifying a form and snytax of a command
associated with said each dialog, said command including a parameter
string for each parameter of said command; and
(b) defining said each parameter, if any, of said command;
and wherein steps (3) and (4) comprise the steps of:
(a) providing values for parameters, if any, of said command associated
with said invoked dialog;
(b) replacing parameter strings, if any, in a command string associated
with said invoked dialog with said parameter values to thereby produce a
modified command string; and
(c) inserting said modified command string into the computer program.
2. The method of claim 1, further comprising the step of:
defining one or more template dialogs each associated with one or more of
said dialogs associated with at least one command.
3. The method of claim 1, wherein the replacing step and the modified
command string inserting step are performed immediately after the
parameter values are provided.
4. The method of claim 1, wherein the computer program performs a task, and
logic underlying the task is at least partially specified by the command
associated with said invoked dialog.
5. The method of claim 1, wherein the computer program performs a task, and
logic underlying the task is at least partially specified by the command
associated with the invoked dialog.
6. The method of claim 1, further comprising the following step that is
performed before step (1):
defining a project to be performed, wherein said project includes one or
more tasks that are to be performed by code generated by invoking one or
more of said dialogs.
7. The method of claim 1, wherein each of said parameters has a parameter
type, wherein said parameter type is one of:
(1) a required parameter;
(2) a user type parameter;
(3) a fixed value parameter;
(4) a multiselect parameter; and
(5) a conditional parameter.
8. An administrator tool box, comprising:
a define dialog module for enabling a first operator to define dialogs
associated with commands from a computer programming language, wherein
each of said commands when executed in a computer causes the computer to
perform a particular function; and
a define parameter module for enabling the first operator to define
parameters of said commands, wherein each of said parameters has a
parameter type, wherein said parameter type is one of a required
parameter, a user type parameter, a fixed value parameter, a multiselect
parameter, an parameter aid a conditional parameter;
wherein a second operator wishing to construct a computer program for
execution on the computer selectively invokes said dialogs, wherein each
of said dialogs, when invoked by the second operator, generates code
corresponding to a command associated with said each of said dialogs, said
code including any parameters of said command, said code being in a form
and having a syntax defined by said computer programming language, said
code being inserted into the computer program being constructed;
wherein said define dialog module comprises means for enabling the first
operator to provide a command string specifying a form and synthax of a
command associated with a dialog being defined, said command string
including a parameter string for each parameter of said command.
9. The administrator tool box of claim 8, wherein said define dialog module
also comprises:
means for enabling the first operator to define one or more template
dialogs each associated with one of said dialogs associated with commands.
10. A system for constructing a computer program, comprising:
dialog invocation means for enabling an operator wishing to construct a
computer program to invoke one of a set of dialogs, said dialogs having
been previously defined and being associated with commands from a computer
programming language, wherein each of said commands causes a computer to
perform a particular function;
code generating means for generating code corresponding to a command
associated with said invoked dialog, said code being in a form and having
a syntax defined by said computer programming language; and
code insertion means for inserting said code into the computer program
being constructed by the operator;
wherein said dialog invocation means comprises means for enable operator to
provide values for parameter, if any, of said command associated with said
invoked dialog, wherein each of said parameters has a parameter type,
wherein said program type is one of a required parameter, a user type
parameter, a fixed value parameter, a multiselect parameter, an optional
parameter, and a conditional parameter.
11. The system of claim 1, wherein said code generating means comprises:
means for replacing parameter strings, if any, in a command string
associated with said invoked dialog with said operator-provided parameter
values to thereby produce a modified command string;
said code insertion means comprising:
means for inserting said modified command string into the computer program.
12. The system of claim 10, further comprising:
define project means for enabling the operator to define a project, wherein
said project includes one or more tasks that are to be performed by code
generated by invoking one or more of said dialogs.
13. A system for constructing a computer program, comprising:
a define dialog module for enabling a first operator to define dialogs
associated with commands from a computer programming language, wherein
each of said commands when executed in a computer causes the computer to
perform a particular function;
wherein said define dialog module comprises:
first means for enabling the first operator to provide a command string
specifying a form and syntax of a command associated with a dialog being
defined, said command string including a parameter string for each
parameter of said command: and
second enabling means for enabling the first operator to define said each
parameter, if any, of said command:
invoking means for enabling a second operator wishing to construct the
computer program to invoke one of said dialogs; said invoking means
comprising third enabling means for enabling the second operator to
provide values for parameters, if any, of said command associated with
said invoked dialog:
code generating means for generating code corresponding to a command
associated with said invoked dialog, said code being in a form and having
a syntax defined by said computer programming language, said code
generating means comprising means for replacing parameter strings, if any,
in a command string associated with said invoked dialog with said
parameter values to thereby produce a modified command string: and
code inserting means for inserting said code into the computer program
being constructed by the second operator, said code inserting means
comprising means for inserting said modified command to the computer
program.
14. The system of claim 13, wherein said define dialog module also
comprises:
means for enabling the first operator to define one or more template
dialogs each associated with one of said dialogs associated with commands.
15. A method of constructing a computer program, comprising the steps of:
(1) defining one or more dialogs each associated with at least one command
from a computer programming language, some of said at least one command
having one or more parameters, each of said at least one command being
defined by a command string in a form and syntax of said computer
programming language, said command string including a parameter string for
each parameter, if any, corresponding to said each of said at least one
command, wherein said each of said at least one command when executed in a
computer causes the computer to perform a particular function, wherein
said dialogs may be invoked by an operator wishing to construct a computer
program:
(2) invoking one of said dialogs;
(3) providing values for parameters, if any, of a command associated with
said invoked dialog;
(4) replacing parameter strings, if any, in a command string associated
with said invoked dialog with said parameter values to thereby produce a
modified command string; and
(5) inserting said modified command string into the computer program being
constructed by the operator.
16. The method of claim 15, wherein steps (4) and (5) are performed
immediately after performing step (3).
17. A system for constructing a computer program, comprising:
dialog invocation means for enabling an operator wishing to construct a
computer program to invoke one of a set of dialogs, said dialogs having
been previously defined and being associated with commands from a computer
programming language, some of said commands having one or more parameters,
each of said commands being defined by a command string in a form and
syntax of said computer programming language, said command string
including a parameter string for each parameter, if any, corresponding to
said each of said commands, wherein each of said commands causes a
computer to perform a particular function:
means for enabling the operator to provide values for parameters of a
command associated with said invoked dialog;
code generating means for generating code corresponding to said command
associated with said invoked dialog, said code generating means also for
replacing parameter strings, if any, in a command string associated with
said invoked dialog with said operator-provided parameter values to
thereby produce a modified command string; and
code insertion means for inserting said modified command string into the
computer program being constructed by the operator.
18. A method of constructing a computer program, comprising the steps of:
(1) invoking a define dialog module of an administrator toolbox to define a
dialog;
(2) entering in a dialog definition window generated by said define dialog
module a dialog name of said dialog being defined; (3) entering in said
dialog definition window generated by said define dialog module a syntax
of at least one command that is being associated with said dialog being
defined;
(4) invoking a define parameter module to define a parameter associated
with said at least one command and associated with said dialog being
defined:
(5) entering in a parameter definition window generated by said define
parameter module a parameter of said parameter being defined; and
(6) entering in said parameter definition window generated by said define
parameter module a string denoting a manner in which said parameter is
represented;
wherein said at least one command is from a computer programming language,
wherein said dialog, when invoked by an operator, generates code
corresponding to said at least one command associated with said dialog,
said code including any parameters of said at least one command, said code
being in a form and having a syntax defined by said computer programming
language, said code being inserted into a computer program being
constructed by said operator.
19. The method of claim 18, wherein said parameter has a parameter type,
wherein said parameter type is one of:
(1) a required parameter;
(2) a user type parameter;
(3) a fixed value parameter;
(4) a multiselect parameter; and
(5) a conditional parameter.
20. A method for constructing a computer program, comprising the steps of:
accepting from an operator a project definition request to define a
project, wherein said project includes one or more tasks that are to be
performed by code generated by invoking one or more dialogs;
enabling the operator to select one of said one or more dialogs, said
selected dialog corresponding to one of said one or more tasks that are to
be performed by said project, wherein each of said dialogs is associated
with at least one command from a computer programming language, wherein
said at least one command when executed in a computer causes the computer
to perform a particular function associated with said at least one
command, wherein said dialogs are invoked by an operator wishing to
construct a computer program;
displaying parameter fields of parameters corresponding to said selected
dialog, if said selected dialog has corresponding parameter fields;
accepting parameter values for said parameter fields corresponding to said
selected dialog;
generating code corresponding to a command associated with said selected
dialog, said code being in a form and having a syntax defined by said
computer programming language; and
inserting said code into the computer program being constructed by said
operator.
21. The method of claim 20, wherein each of said parameters has a parameter
type, wherein said parameter type is one of:
(1) a required parameter;
(2) a user parameter;
(3) a fixed value parameter;
(4) a multiselect parameter; and
(5) a conditional parameter.
22. A method for constructing a computer program, comprising the steps of:
(a) defining a project to be performed, wherein said project includes one
or more tasks that are to be performed;
(b) instantiating an object wherein instantiating an object comprises the
following steps:
(i) displaying a list of defend object classes;
(ii) providing a name for a new object by an operator;
(iii) displaying a bitmap of said new object;
(iv) displaying an attribute table with one or more attributes associated
with said new object;
(v) entering attribute values by said operator for each of said one or more
attributes associated with said new object; and
(vi) repeating steps (i) to (V) until all objects for said project have
been instantiated;
(c) selecting an object associated with at least one of said one or more
tasks to be performed by said project;
(d) selecting at least one method associated with said selected object;
(e) generating code associated with said at least one method; and
(f) inserting said code into the computer program being constructed.
23. The method of claim 22 comprising the step of defining an object class
after step (a) and before step (b).
24. The method of claim 23, wherein the step of defining an object class
comprises the following steps:
receiving an object class definition entered by said operator;
receiving object attribute information entered by said operator; and
receiving new object method information entered by said operator.
25. The method of claim 22, wherein step (d) comprises the step's of:
requesting a list of one or more methods associated with said selected
object; and
selecting at least one of said one or more methods associated with said
selected object;
wherein each of said one or more methods is associated with at least one
dialog that was selected by an operator during definition of said each of
said one or more methods, wherein said at least one dialog is associated
with at least one command from a computer programming language, wherein
said at least one command when executed in a computer causes the computer
to perform a particular function associated with said at least one
command.
26. A system for constructing a computer program, comprising:
means for accepting a project definition request to define a project,
wherein said project includes one or more tasks that are to be performed
by code generated by invoking one or more dialogs;
means for enabling an operator to invoke one of said one or more dialogs,
said invoked dialog corresponding to one of said one or more tasks that
are to be performed by said project, wherein each of said dialogs is
associated with at least one command from a computer programming language,
wherein said at least one command when executed in a computer causes the
computer to perform a particular function associated with said at least
one command, wherein said dialogs are invoked by an operator wishing to
construct a computer program;
means for displaying parameter fields of parameters corresponding to said
invoked dialog, if said invoked dialog has corresponding parameter fields;
means for accepting parameter values for said parameter fields
corresponding to said invoked dialog;
means for generating code corresponding to a command associated with said
invoked dialog, said code being in a form and having a syntax defined by
said computer programming language; and
means for inserting said code into the computer program being constructed
by said operator.
27. The system of claim 26, wherein each of said parameters has a parameter
type, wherein said parameter type is one of:
(1) a required parameter;
(2) a user parameter;
(3) a fixed value parameter;
(4) a multiselect parameter; and
(5) a conditional parameter.
28. A system for constructing a computer program, comprising:
means for defining a project to be performed, wherein said project includes
one or more tasks that are to be performed;
means for instantiating an object wherein said means for instantiating an
object comprises:
means for displaying a list of defined object classes;
means for displaying a bitmap of said new object
means for displaying an attributable with one or more attributes associated
with said new object; and
means for providing a name for a new object by an operator;
means for entering attributes values by said operator for each of said one
or more attributes associated with said new object;
means for selecting an object associated with at least one of said one or
more tasks to be performed by said project;
means for selecting at least one method associated with said selected
object;
means for generating code associated with said selected method; and
means for inserting said code into the computer program being constructed.
29. The system of claim 28, further comprising:
means for defining an object class.
30. The system of claim 29, wherein the means for defining an object class
comprises:
means for receiving object class definition entered by said operator;
means for receiving object attribute information entered by said operator;
and
means for receiving new object method information entered by said operator.
31. The system of claim 28, wherein said means for selecting at least one
method associated with said object comprises:
means for requesting a list of one or more methods associated with said
selected object; and
means for selecting at least one of said one or more methods associated
with said selected object;
wherein each of said one or more methods is associated with at least one
dialog that was selected by an operator during definition of said each of
said one or more methods, wherein said at least one dialog is associated
with at least one command from a computer programming language, wherein
said at least one command when executed in a computer causes the computer
to perform a particular function associated with said at least one
command.
Description
CROSS-REFERENCE TO OTHER APPLICATIONS
The following applications of common assignee contain some common
disclosure, and are believed to have an effective filing date identical
with that of the present application.
"A Computer Program Product For Enabling the Construction of Dialogs for
Commands and Templates," Attorney Docket 1252.2190000, incorporated herein
by reference.
"System and Method for Constructing Computer Programs Using Dialogs and
Objects," Attorney Docket No. ST9-95-006 (1252.2080000), incorporated
herein by reference.
"A Computer Program Product for Enabling the Construction of Computer
Programs Using Dialogs and Objects," Attorney Docket No. 1252.2180000,
incorporated herein by reference.
BACKGROUND OF THE INVENTION
1. Field of the Invention
The present invention relates generally to the construction of computer
programs (software), and more particularly to the construction of computer
programs using dialogs and objects.
2. Related Art
The generation of computer programs is complicated by a number of factors.
One factor is the complexity of the syntax and structure of many computer
programming languages. Another factor, which relates to a computer program
that is intended to control a system (such software is called a system
control program), is the complexity of the specification that defines the
system. These complicating factors make it difficult for even the most
experienced computer programmers to write computer programs, and almost
impossible for less experienced programmers to write computer programs.
Consider, for example, a database system environment where periodic system
maintenance must be performed to maintain system resources. Such system
maintenance involves routine tasks (such as an off-line copy) and
non-routine tasks (such as a database recovery operation). These routine
and non-routine tasks are performed by generating and executing system
control programs. The system control programs are written in an
appropriate computer program language, such as Job Control Language (JCL).
The structure and syntax of JCL is complex and difficult to specify. Also,
database system environments are often very complex. For example, if a
task involved recovering fifty databases, then it would be necessary to
know the attributes (such as the name, volume, space, etc.) for all of the
databases, so as to construct the proper JCL computer program to perform
the recovery task. The collection of such attribute information is very
complex. These complexities make it difficult to construct system control
programs.
Thus, what is required is a system and method for facilitating the
construction of computer programs.
SUMMARY OF THE INVENTION
Briefly stated, the invention is directed to a system and method for
facilitating the construction of computer programs. The invention enables
an administrator to define dialogs associated with commands from a
computer programming language. According to the invention, users construct
computer programs by using the dialogs. In particular, an user invokes a
dialog, and then the invention generates code corresponding to a command
associated with the invoked dialog. The code is in a form and has a syntax
defined by the computer programming language. The code is inserted into
the computer program being constructed.
The invention also provides for the construction of computer programs using
dialogs and objects. In particular, a plurality of objects each
corresponding to a resource in a target environment are defined and
instantiated from a plurality of object classes. At least one of the
dialogs is associated with each of the objects. An operator selects one or
more of the objects (representing the resources in a system), and invokes
a dialog associated with the selected objects. The invention generates
code that, when executed, applies a command associated with the invoked
dialog to each of the selected objects. The code is in a form and has a
syntax defined by the computer programming language. This code is inserted
in the computer program being constructed.
Further features and advantages of the invention, as well as the structure
and operation of various embodiments of the invention, are described in
detail below with reference to the accompanying drawings. In the drawings,
like reference numbers generally indicate identical, functionally similar,
and/or structurally similar elements. The drawing in which an element
first appears is indicated by the digit(s) to the left of the two
rightmost digits in the corresponding reference number.
BRIEF DESCRIPTION OF THE FIGURES
The present invention will be described with reference to the accompanying
drawings, wherein:
FIG. 1 generally illustrates the manner in which dialogs and objects are
generated from an administrator tool box, and the manner in which such
dialogs and objects are used to generate computer programs;
FIG. 2 is a block diagram of the administrator tool box according to a
preferred embodiment of the invention;
FIG. 3 is a block diagram of a preferred computer system of the present
invention;
FIGS. 4, 5, 9A, 9B, 10 and 17 are flowcharts depicting the operation of the
presenting invention;
FIGS. 6, 7, 8, 11, 12, and 13 are exemplary windows used by the invention
to interact with administrators and users;
FIG. 14 illustrates an example display of bitmaps associated with objects;
FIG. 15 illustrates attribute tables associated with the objects of FIG.
14; and
FIG. 16 illustrates an example attribute table.
DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS
The present invention is a system and method for facilitating the
construction of computer programs using dialogs for commands (from a
computer programming language) and templates.
In an embodiment of the invention, JCL (Job Control Language) is used as
the computer programming language, although other computer programming
languages could alternatively be used. Also, the computer programs
constructed by the invention represent system control programs, although
other types of computer programs could alternatively be constructed.
Generally speaking, the invention is useful for constructing computer
programs where (1) the syntax and structure of the computer programming
language are complex, and/or (2) the target environment (i.e., the
computing environment in which the computer programs are to be executed)
is complex. However, it should be understood that the invention can also
be used to construct computer programs where neither (1) nor (2) is true.
An administrator (defined as a person experienced with the computer
programming language and the target environment) generates a dialog for a
command (called a command dialog) by specifying the format and the syntax
of the command. The administrator generates a dialog for a template
(called a template dialog) by specifying a group of command dialogs, where
the commands associated with the command dialogs are collectively useful
for performing a task.
An user (defined as a person less experienced with the computer programming
language and/or the target environment) generates a computer program by
invoking a command dialog associated with a command useful for performing
a desired task. Upon invocation, the dialog interacts with the user to
obtain parameter values necessary to execute the command. The command and
parameter values are then automatically written to the computer program in
the proper format and syntax. The user continues to invoke command and
template dialogs until the computer program is complete. (It should be
understood that the administrator could also invoke dialogs to construct
computer programs.)
As shown in FIG. 1, the invention provides an administrator tool box 106
containing tools that an administrator 104 uses to generate dialogs and
objects 108 (objects are described below). Users 110 utilize the dialogs
to generate computer programs 112.
Accordingly, the users 110 do not have to have a detailed understanding of
the computer programming language or the target environment in order to
construct computer programs. Instead, the users 110 need only invoke
dialogs to construct computer programs. Accordingly, the present invention
facilitates the construction of computer programs. Additionally, since
computer programs 112 are constructed by invoking dialogs (rather than by
writing code directly), the invention promotes and enhances software
reusability and standardization.
FIG. 2 is a block diagram of the administrator tool box 106. The
administrator tool box 106 includes a define dialog module 202, a define
parameter module 204, a define object class module 206, a define new
object method module 208, and a define object attribute module 210. These
modules 202, 204, 206, 208, 210 represent tools that the administrator 104
can use to generate dialogs and objects 108. These modules 202, 204, 206,
208, 210 are preferably software modules/programs written in any well
known and appropriate computer language. These modules 202, 204, 206, 208,
210 are further described below.
FIG. 3 is a block diagram of a computer system 302. This computer system
302 could be used by the administrator 104 to generate the dialogs and
objects 108. This computer system 302 could also be used by the users 110
to generate computer programs 112 using the dialogs and objects 108
(alternatively, the administrator 104 and the users 110 could operate on
different computer systems). The computer system 302 can be implemented
using any suitable commercially available computer system.
The computer system 302 includes one or more processors, such as CPU
(central processing unit) 304, connected to a bus 306. Also connected to
the bus 306 are a number of memory/storage devices and components 308
representing, for example, main memory RAM (random access memory), a hard
drive, removable storage devices such as floppy drives, CD drives, and
tape drives, and computer program products such as computer storage disks,
compact disks, optical disks, magnetic tapes, etc. Such computer program
products have computer readable mediums with data and control logic
(software) recorded thereon.
Stored in the memory/storage devices and components 308 are the
administrator tool box 106, the dialogs and objects 108, attribute tables
312, supervisory control logic 314, and user computer programs 112. These
are described below.
The computer system 302 also includes a display device 316 (such as a
monitor) and one or more input devices 318 (such as a keyboard, mouse,
track ball, etc.).
Generating Computer Programs By Using Dialogs
The manner in which a computer program 112 is constructed through the use
of dialogs shall now be described in detail with reference to a flowchart
402 presented in FIG. 4. Flowchart 402 begins with step 404, where control
immediately passes to step 406.
In step 406, the administrator 104 creates a plurality of dialogs using the
tools in the administrator tool box 106. In practice, the administrator
104 creates a dialog for each task and/or function that may later form
part of or all of a computer program 112. For example, in a database
environment, the administrator 104 may create a dialog for an off-line
image copy function, a dialog for a database recovery function, etc. It
should be understood that the creation of dialogs by the administrator 104
is preferably an ongoing process. Over time, in response to requests from
users 110, for example, new dialogs are created, and old dialogs are
modified and/or deleted. Accordingly, the performance of step 406 occurs
repeatedly over time, and not necessarily in the order shown in FIG. 4.
Step 406 shall now be described in greater detail with reference to a
flowchart 502 in FIG. 5, which depicts the manner in which a single dialog
for a command is defined. Flowchart 502 is performed for each command
dialog that the administrator 104 wishes to define. Flowchart 502 begins
with step 504, where control immediately passes to step 506.
In step 506, the administrator 104 indicates that he wishes to interact
with the define dialog module 202. The administrator 104 preferably does
this by invoking the define dialog module 202 in any well known manner,
such as by selecting (with a pointing device, for example) an icon
corresponding to the define dialog module 202. It is noted that the user
interface functionality described in this paragraph (i.e., displaying the
icon corresponding to the define dialog module 202, and responding to an
user command via a pointing device to invoke the define dialog module 202)
is provided by the supervisory control logic 112 in a well known manner.
In step 508, the define dialog module 202 displays a dialog definition
window 602 as shown in FIG. 6. The dialog definition window 602 includes a
dialog name field 603 in which the administrator 104 can enter the name of
the dialog being defined, a command field 604 in which the administrator
104 may enter the format/syntax of one or more commands (the format/syntax
for each command is also called a command string), a define new parameter
button 606 which the administrator 104 may press in a well known manner to
define a parameter of the command, and a done button 608 which the
administrator 104 may press in a well known manner once the command has
been completely defined.
In step 510, the define dialog module 202 receives from the administrator
104 the format/syntax for one or more commands. These commands are
displayed in the command field 604. These commands are from the computer
programming language of the computer program 112 being constructed. Thus,
if the computer programming language is JCL, then these commands would be
from the JCL computer programming language. In the example shown in FIG.
6, the define dialog module 202 in step 510 received from the
administrator 104 the format/syntax of the "define cluster" command.
This command has three parameters, denoted by &DS, &Vol, and &SP in the
command field 604 (these are each also called a parameter string).
However, the administrator 104 has not yet defined these parameters. The
administrator 104 defines a parameter by pressing the define new parameter
button 606, at which time the define parameter module 204 is invoked. The
define parameter module 204 performs step 512. (Note that, if the command
does not have any parameters, then control moves to step 516 as indicated
by control line 511. In practice, control flows to step 516 after
receiving an appropriate command from the administrator 104, such as when
the administrator 104 presses the done button 608. Step 516 is described
below.)
In step 512, the define parameter module 204 displays a parameter
definition window 702 as shown in FIG. 7. The parameter definition window
702 has a parameter name field 704 in which the administrator 104 may
enter the name of the parameter being defined, a string field 706 in which
the administrator 104 may enter a string denoting the manner in which the
parameter is represented in the command in question (i.e., the command
displayed in the command field 604 of the dialog definition window 602),
an object attributes field 708 in which the administrator 104 may indicate
the object attribute that applies to the parameter (if any), a parameter
type field 710 in which the administrator 104 may indicate the parameter
type(s) of the parameter, and a done button 711 which the administrator
104 may press after the parameter has been completely defined.
In step 514, the define parameter module 204 receives from the
administrator 104 parameter definition information, and displays this
parameter definition information in the appropriate fields of the
parameter definition window 702. In the example of FIG. 7, the parameter
being defined is the Data Set Name parameter as shown in the parameter
name field 704. This parameter is represented by the string "&DS" in the
command in question (see the command field 604 in FIG. 6), as indicated in
the string field 706. The administrator 104 has indicated that this
parameter represents a "dataset name" object attribute, as indicated by
the check mark beside the "dataset name" entry in the object attributes
field 708 (object attributes are discussed in greater detail below). The
administrator 104 has also indicated that this parameter is a required
user type parameter, as indicated by the check marks next to the
"Required" and "User Type" entries in the parameter type field 710. Before
proceeding further, it will be useful to discuss the preferred parameter
types supported by the invention.
A required parameter (indicated by selecting the "Required" entry in the
parameter type field 710) is one whose value must be provided by the user
110 when the associated dialog is invoked. An optional parameter
(indicated by selecting the "Optional" entry in the parameter type field
710) is one whose value may be, but need not be, provided by the user 110
when the associated dialog is invoked.
A user type parameter (indicated by selecting the "User Type" entry in the
parameter type field 710) is one whose value must be entered by the user
110 when the associated dialog is invoked. Preferably, when the dialog is
invoked, the invention displays a conventional edit box to enable the user
110 to enter the value.
A fixed value parameter (indicated by selecting the "Fixed Value" entry in
the parameter type field 710) is one that may only have a certain set of
possible values. The administrator 104 must provide these values when the
parameter is being defined. These values are displayed when the dialog is
invoked, and the user 110 is required to select one of these values.
A multiselect parameter (indicated by selecting the "Multiselect" entry in
the parameter type field 710) is one that can have multiple values. These
values are entered by the user 110 (each value being separated by a
delimiter, such as a comma or a semi-colon) when the dialog is invoked.
A conditional parameter (indicated by selecting the "Conditional" entry in
the parameter type field 710) is one whose existence is conditional on the
state of another parameter. The value for the conditional parameter is
only entered by the user 110 if the condition is satisfied. Likewise, the
conditional parameter only affects the execution of the command if the
condition is satisfied. For example, supposes there are parameters P1 and
P2. P2 can be defined to be conditional on whether or not a value of P1 is
provided (in the case where P1 is an optional parameter). As another
example, P2 can be defined to be conditional on whether or not P1 is equal
to a certain value.
Some commands or templates may include other commands or templates in their
representation. This represents an additional flexibility of the
invention. This capability is achieved by the invention by the use of
dialog parameters. A dialog parameter (indicated by selecting the "Dialog"
entry in the parameter type field 710) is one whose value identifies
another dialog. The command or template associated with this other dialog
becomes embedded in the command in question.
The invention is not limited to the parameter types discussed above. Other
parameter types will be apparent to persons skilled in the relevant
art(s).
The dialog definition window 602 is redisplayed after all parameter
definition information has been entered by the administrator 104 and
received by the define parameter module 204 in step 514. In practice, this
occurs after the administrator 104 has pressed the done button 711 in the
parameter definition window 702. At this point (i.e., after the
administrator 104 has pressed the done button 711 and the dialog
definition window 602 has been redisplayed), the administrator 104 may
define another parameter of the command in question by again pressing the
defme new parameter button 606 (at which time control returns to step 512
as indicated by control line 515). In practice, the administrator 104
presses the define new parameter button 606 once for each parameter of the
command in question, so as to define each parameter.
If the administrator 104 has completed the definition of the dialog, then
the administrator 104 presses the done button 608 in the dialog definition
window 602. Processing of flowchart 502 is then complete as indicated by
step 516. Information pertaining to this new dialog is saved, preferably
as a record in a relational database table, for later access and
processing. A dialog has been completely defined once its format/syntax
has been defined, and once all of its parameters have been defined.
As indicated above, flowchart 502 represents the operation of the invention
when defining a dialog for a command. The manner in which a dialog for a
template is defined is similar to that shown in flowchart 502. However,
when defining a template dialog, the define dialog module 202 in step 510
receives information from the administrator 104 that specifies one or more
existing dialogs for inclusion in the new dialog being created. (When the
new template dialog is invoked, each of the dialogs which form part of the
new template dialog will be invoked in turn.) Template dialogs can also
have their own parameters, in which case steps 512 and 514 are performed.
Referring again to FIG. 4, the user 110 performs steps 408-422 to construct
a computer program 112 using dialogs. The user 110 uses the dialogs
constructed by the administrator 104 in step 406 to construct this
computer program 112. Steps 408-422 shall now be described.
In step 408, the user 110 identifies a project or job that must be
performed. The project may be to recover a database, or to perform an
off-line edit, for example. The project may include one or more tasks. In
steps 410-422, the user 110 uses the dialogs to construct a computer
program 112 to perform this project.
Specifically, in step 410, the user 110 selects (from a catalog, for
example) a dialog that is pertinent to the project. For example, the
selected dialog may correspond to a command that, when executed, performs
one of the tasks of the project.
In step 412, the invention displays a parameter value entry window 802
(FIG. 8) that corresponds to the selected dialog and, more particularly,
that corresponds to the command associated with the selected dialog (the
display and the user interaction with the parameter value entry window 802
may be controlled by the supervisory control logic 314, for example). The
parameter value entry window 802 has a field for each parameter of the
command. The user 110 is able to enter values for these parameters in
these fields.
For example, suppose that the selected dialog corresponds to the "Define
cluster" command (the definition of which is shown in FIG. 6). This
command has three parameters, &DS, &Vol, and &SP. The example parameter
value entry window 802 shown in FIG. 8 corresponds to this dialog.
Accordingly, the parameter value entry window 802 includes fields for
these parameters, i.e., a data set name field 804 for parameter &DS, a
volume field 806 for parameter &Vol, and a space field 808 for parameter
&SP. The format and content of these fields correspond to the parameter
types of these parameters. For example, if a parameter is defined as being
a user type, then an edit box is presented. If a parameter is defined as
being a fixed value parameter, then a list of possible values is
presented. The user 110 enters values for the parameters into these fields
804, 806, 808.
In step 414, the invention (in particular, the supervisory control logic
314) receives these parameter values from the user 110.
In step 416, the invention (in particular, the supervisory control logic
314) generates code representative of the selected dialog and the
user-provided parameter values. The code is in the computer programming
language of the computer program 112 being generated. Also, the code is in
the proper format and syntax as defined and required by the computer
programming language.
The invention preferably performs step 416 by retrieving the command string
that was displayed in the command field 604 of the dialog definition
window 602, and then replacing the parameter strings in this command
string with the parameter values provided by the user 110. For example,
suppose that the selected dialog corresponds to the define cluster
command, and that in step 414 the user entered DSN1 for the Data Set Name
parameter, V1 for the Volume parameter, and SP1 for the Space parameter.
In step 416, the invention preferably retrieves the following command
string that represents the define cluster command (refer to FIG. 6):
Define cluster &DS, &Vol, &SP
There are three parameter strings in this command string: &DS, &Vol, and
&SP. The invention replaces these parameter strings with the user-provided
parameter values, to thereby generate the following code:
Define cluster DSN1, V1, SP1
This code is in the computer programming language of the computer program
112 being generated, and is in the proper format and syntax as defined and
required by the computer programming language. Note, however, that the
user 110 did not have to have a detailed understanding of the computer
programming language in order to generate this code. Instead, the user 110
generated this code simply by invoking the appropriate dialog and
providing the parameter values.
In step 418, the invention (preferably the supervisory control logic 314)
adds the code to the computer program 112 being generated. In one
embodiment, the invention appends the code to the computer program 112,
although the user 110 may indicate other ways for inserting the code into
the computer program 112.
In step 420, the user 110 determines whether the project identified in step
408 has been completely addressed by the computer program 112. If the
project has not been completely addressed, then control flows back to step
410 to enable the user 110 to continue to generate the computer program
112 (alternatively, control flows along control line 421, which is
described below). Otherwise, generation of the computer program 112 is
complete, and flowchart 402 terminates, as indicated by step 422.
Generating Computer Programs By Applying Dialogs to Objects
According to the present invention, it is possible to defme and instantiate
objects that represent system components and resources. Once defined and
instantiated, objects can be grouped together to represent the resources
in a specific system. Dialogs may then be applied to any subset of these
objects, to thereby generate a computer program 112 having code that, when
executed, operates with the resources associated with the objects.
Accordingly, this aspect of the invention represents another way for
generating computer programs 112. The generation of computer programs 112
through the use of dialogs and objects shall now be further described with
reference to a flowchart 902 in FIGS. 9A and 9B. Flowchart 902 begins with
step 904, where control immediately passes to step 906.
In step 906, the administrator 104 creates a plurality of object classes
using the tools in the administrator tool box 106. In practice, the
administrator 104 creates an object class for each type of
resource/component of interest in the target environment. For example,
suppose that a business environment includes a plurality of payroll
databases each having the same attributes. In this case, the administrator
104 may create an object class to represent such payroll databases. The
business environment may also include a plurality of database logs, a
plurality of personnel databases, and a plurality of image copies. In this
case, the administrator 104 may create an object class to represent the
database logs, another object class to represent the personnel databases,
and another object class to represent the image copies.
It should be understood that the creation of object classes by the
administrator 104 is preferably an ongoing process. Over time, in response
to requests from users 110, for example, new object classes are created,
and old object classes are modified and/or deleted. Accordingly, the
performance of step 906 occurs repeatedly over time, and not necessarily
in the order shown in FIG. 9. Also, new objects can be created by means of
inheritance from existing objects. The details of such object creation
will be apparent to persons skilled in the relevant art(s) based, at least
in part, on the discussion contained herein.
Note that the administrator 104 preferably performs both step 906, to
create object classes, and step 406 (FIG. 4), to create dialogs. Thus,
prior to performing step 908, a plurality of object classes and dialogs
exist. The definition of object classes depends on the definition of
dialogs, and vice versa. This is described below.
Step 906 shall now be described in greater detail with reference to a
flowchart 1002 in FIG. 10, which depicts the manner in which a single
object class for a system resource/component is defined. Flowchart 1002 is
performed for each object class that the administrator 104 wishes to
define. Flowchart 1002 begins with step 1004, where control immediately
passes to step 1006.
In step 1006, the administrator 104 indicates that he wishes to interact
with the define object class module 206. The administrator 104 preferably
does this by invoking the defme object class module 206 in any well known
manner, such as by selecting (with a pointing device, for example) an icon
corresponding to the define object class module 206. It is noted that the
user interface functionality described in this paragraph (i.e., displaying
the icon corresponding to the define object class module 206, and
responding to an user command via a pointing device to invoke the define
object class module 206) is provided by the supervisory control logic 112
in a well known manner.
In step 1008, the define object class module 206 displays an object class
definition window 1102 as shown in FIG. 11. The object class definition
window 1102 includes an object class name field 1104 in which the
administrator 104 can enter the name of the object class being defined, an
object attributes field 1106 in which the administrator 104 can indicate
which object attributes apply to the object class, a bitmap field 1108 in
which the administrator 104 can select a bitmap (icon) to represent
instantiations of the object class, an object methods field 112 that lists
methods that apply to the object class, a new method button 1114 that the
administrator 104 can press when he wishes to add a new method to the
object methods field 112, an edit method button 1116 that the
administrator 104 can press when he wishes to edit one of the methods in
the object methods field 1112, and a done button 1117 that the
administrator 104 can press when the object class has been completely
defined.
Also in step 1008, the define object class module 206 receives from the
administrator 104 object class definition information, and displays this
information in the appropriate fields of the object class definition
window 1102. In the example of FIG. 11, the object class being defined is
called DB, as indicated in the object class name field 1104 (DB stands for
database).
The administrator 104 has selected a bitmap 1110 that resembles a cylinder,
as indicated in the bitmap field 1108.
The object attributes associated with object class DB are database name,
volume, and space, as indicated by the check marks in the object
attributes field 1106. This means that the system resources/components
represented by the object class DB each has these three attributes.
In practice, the administrator 104 first identifies the attributes
associated with the system resources/components in question (i.e., the
system resources/components that are to be represented by the object class
being defined). Then, the administrator 104 associates these attributes
with the object class by selecting the corresponding entries in the object
attributes field 1106.
The object attributes field 1106 lists all object attributes that are
defined. If an attribute associated with the system resources/components
does not have a corresponding entry in the object attributes field 1106,
then the administrator 104 invokes the define object attribute module 210
(this is also part of step 1008). The define object attribute module 210
then displays an object attribute definition window 1202, as shown in FIG.
12.
The object attribute definition window 1202 includes an attribute name
field 1204 in which the administrator 104 may enter the name of the
attribute being defined, an object attribute check box 1206 where the
administrator 104 can indicate whether this attribute is an object
attribute, and a done button 1208 which the administrator 104 presses once
the attribute has been completely defined.
In the example of FIG. 12, the space attribute is being defined as
indicated in the attribute name field 1204. This attribute is an object
attribute, as indicated by the check in the object attribute check box
1206. If this box 1206 is not checked, then the attribute is a global
variable (such as Global Var1 and Global Var2 in the object attributes
field 1106 of FIG. 11), which is a variable that can be shared among
multiple objects. After the administrator 104 presses the done button
1208, the attribute being defined (i.e., the space attribute) appears in
the object attributes field 1106.
The object methods associated with the DB object class are define,
utilities, and image copy. These methods are those that can be applied to
instantiations (i.e., DB objects) of the DB object class. According to the
present invention, an object method is a dialog. Thus, define, utilities,
and image copy are dialogs that were previously defined by the
administrator 104 in step 406 (FIG. 4). These dialogs can be applied to
instantiations of the DB object class.
The administrator 104 associates a new method with the DB object class by
pressing the new method button 1114 (this is also part of step 1008). This
results in invoking the defme new object method module 208.
The define new object method module 208 displays a new object method
definition window 1302, as shown in FIG. 13. The new object method
definition window 1302 includes a method name field 1304 in which the
administrator 104 can enter the name of the method being defined and
associated with the object class, an available dialogs field 1306 in which
the administrator 104 can select the dialog(s) to be associated with the
method, and a done button 1308 that the administrator 104 can press once
the new method has been defined.
In the example of FIG. 13, the define method is being defined, as indicated
by the method name field 1304. The available dialogs field 1306 lists all
dialogs presently defined (not all dialogs are shown in FIG. 13). The
administrator 104 has indicated that dialog defc1 (associated with the
define cluster command, as shown in FIG. 6) should be associated with the
define method. This is indicated by the check mark in the available
dialogs field 1306. If a required dialog has not yet been defined, then
the administrator 104 must define the dialog in the manner described
above.
If the administrator 104 wishes to edit a method listed in the object
methods field 1112 (FIG. 11), then the administrator 104 presses the edit
method button 1116. A window such as the new object method definition
window 1302 is then displayed. The administrator 104 can then select and
edit a method via this window.
The administrator 104 presses the done button 1117 once the object class
has been defined. At that time, the object class definition information
for the object class are stored, preferably as a record in a relational
database.
Referring again to FIG. 9A, step 908 is performed after the administrator
104 has defined all desired object classes in step 906. Before describing
step 908, however, it will be useful to revisit the definition of a dialog
and a parameter as shown in FIGS. 6 and 7, respectively. As noted above,
the invention allows a method (i.e., a dialog) to be applied against an
object. To accomplish this, the invention provides a mechanism to link a
dialog with an object. One part of this linkage is the object methods
field 1112. The object methods field 1112 in the example of FIG. 11
indicates that the DB object class is associated with the define,
utilities, and image copy methods. With respect to the defme method, note
that this method is represented by the defc1 dialog (FIG. 13). Thus, the
DB object class is linked to the defc1 dialog.
The invention provides additional linkage between dialogs and objects.
Referring to FIG. 6, note that the define cluster command has three
parameters: &DS, &Vol, and &SP. FIG. 7 illustrates the definition of the
&DS (Data Set Name) parameter. Note that this parameter is indicated in
the object attributes field 708 as being a dataset name object attribute.
In FIG. 11, note that the DB object class has as one of its object
attributes the dataset name object attribute. Thus, the DB object class
and the Data Set Name parameter (&DS) have in common the dataset name
object attribute. Accordingly, the DB object class and the Data Set Name
parameter are linked by the dataset name object attribute. In particular,
when the defcl dialog is invoked, values for the Data Set Name (&DS)
parameter in the define cluster command are obtained from the dataset name
attribute of instances of the DB object class (instead of being provided
through execution time interaction with the user 110). This is further
described below.
Referring again to FIGS. 9A and 9B, the user 110 performs steps 908-932 to
construct a computer program 112 using dialogs and objects. Steps 908-932
shall now be described.
In step 908, the user 110 identifies a project or job that must be
performed. The project may be to recover a database, or to perform an
off-line edit, for example. The project may include one or more tasks. In
steps 910416-932, the user 110 uses the dialogs and objects to construct a
computer program 112 to perform this project.
In step 910, the user 110 determines whether all objects (i.e.,
instantiations of object classes) needed to perform the project have been
instantiated. The user 110 preferably performs step 910 by identifying all
of the resources/components in the target system that are needed to
perform the project. The user 110 then determines whether an object has
been instantiated for each of these resources/components. If an object has
been instantiated for each of these resources/components, then step 920 is
performed (described below). Otherwise, steps 912-918 are performed,
wherein an object is instantiated for each resource/component that does
not already have an object.
Specifically, in step 912 the invention (preferably the supervisory control
logic 314) displays a list of all object classes currently defmed. The
user 110 selects an object class that represents one of the
resources/components that does not already have an object (this is called
the "current resource/component" for reference purposes). For illustrative
purposes, assume that the current resource/component is a database, and
that the selected object class is the DB object class.
In step 914, the user 110 provides a name for the object (called the "new
object" for reference purposes) which the user 110 wishes to instantiate
to represent the current resource/component. For illustrative purposes,
assume that the user 110 calls this new object "Payroll3."
In step 916, the invention (in particular, the supervisory control logic
314) displays the bitmap 1410 of object Payroll3. This is shown in FIG.
14. Note that objects Payrolll and Payroll2 were previously created, and
are also instantiations of the DB object class. The previously-created
object called Log is an instantiation of a different object class.
In step 918, the user 110 requests that the attribute table associated with
object Payroll3 be displayed. According to the invention, associated with
each object is an attribute table (these are shown as attribute tables 312
in FIG. 3). See FIG. 15. The attribute table for an object includes a
column for each object attribute of the object's object class. FIG. 16
illustrates the attribute table 1510 for the object Payroll3, which is
displayed pursuant to the user's 110 request in step 918. This attribute
table 1510 includes a dataset name column, a volume column, and a space
column, corresponding to the object attributes of the DB object class (see
FIG. 11).
As will be appreciated, a database includes one or more datasets. Recall
that the current resource/component is a database. Thus, the attribute
table 1510 includes a row for each dataset associated with the Payroll3
object (and ultimately associated with the current resource/component). In
step 918, the user 110 enters attribute values for each dataset in the
current resource/component. If the current resource/component has 1000
datasets, then the user 110 would create 1000 rows in the attribute table
1510, and the user 110 would enter the dataset name, volume, and space of
each dataset in the row corresponding to that dataset.
Control then returns to step 910, as indicated by control line 919. As
discussed above, in step 910 the user 110 determines whether all objects
needed to perform the project have been instantiated. If all such objects
have been instantiated, then step 920 is performed. Step 920 shall now be
described.
In step 920, the user 110 selects in a well known manner all objects
pertinent to the project. The user 110 may do this, for example, by using
a mouse in a well known manner to select each such object. Assume for
illustrative purposes that the user 110 selects Payroll 1, Payroll2, and
Payroll3.
In step 922, the user 110 requests a list of all methods associated with
these selected objects. These objects are of class DB. Associated with
class DB are the methods define, utilities, and image copy (see FIG. 11).
Thus, pursuant to the user 110's request, a list specifying methods defme,
utilities, and image copy is displayed. The user 110 then selects one of
these methods. Assume, for illustrative purposes, that the user 110
selects the define method. In effect, the user 110 is requesting that the
invention generate code that, when executed, will apply the define method
against objects Payrolll, Payroll2, and Payroll3.
In step 924, the invention (in particular, the supervisory control logic
314) displays the parameter value entry window(s) for the selected method
(recall that a method is a dialog). In this case, the parameter value
entry window 802 shown in FIG. 8 is displayed. In this case, the user 110
need not enter any parameter value information, as this information will
all be retrieved from the attribute tables associated with the objects
Payrolll, Payroll2, and Payroll3. In some cases, however, there may be
some parameters that will not be filled in using information from
attribute tables. In such cases, the user 110 in step 924 supplies such
parameter value information.
In step 926, the invention (in particular, the supervisory control logic
314) generates code so as to apply the selected method to the selected
objects Payroll1, Payroll2, and Payroll3. The code is in the computer
programming language of the computer program 112 being generated. Also,
the code is in the proper format and syntax as defined and required by the
computer programming language.
The manner in which step 926 is performed is shown in a flowchart 1702 in
FIG. 17. Flowchart 1702 begins with step 1704, where control immediately
flows to step 1706.
In step 1706, the invention generates code so as to process each row of the
attribute tables 1506, 1508, 1510 associated with the selected objects
Payroll , Payroll2, and Payroll3. In another embodiment, the user 110 may
select a subset of the rows from these attribute tables 1506, 1508, 1510,
and the invention would then generate code so as to process each of these
rows.
In step 1708, the invention generates inner-loop code to apply the selected
method to a row. This code is generated such that values for parameters of
the method are extracted from the row, where possible. Otherwise,
parameter values entered by the user 110 in step 924 are used.
For example, the define method is implemented using the defcl dialog (FIG.
13), which corresponds to the define cluster command (FIG. 6). The define
cluster command has three parameters, &DS, &Vol, and &SP. The &DS
parameter is a dataset name object attribute (FIG. 7) that is linked to
the dataset name column in the attribute tables 1506, 1508, 1510 (FIG.
16). Also, the &Vol parameter is a volume object attribute that is linked
to the volume column in the attribute tables 1506, 1508, 1510, and the &SP
parameter is a space object attribute that is linked to the space column
in the attribute tables 1506, 1508, 1510 (these links are not explicitly
shown in the drawings). Thus, in step 1708 the invention generates the
code such that values for the &DS, &Vol, and &SP parameters in the define
cluster command are retrieved from the rows of the attribute tables 1506,
1508, 1510.
Flowchart 1702 is complete after step 1708 is performed, as indicated by
step 1710.
Referring again to FIG. 9B, in step 928 the invention (preferably the
supervisory control logic 314) adds the code to the computer program 112
being generated. In one embodiment, the invention appends the code to the
computer program 112, although the user 110 may indicate other ways for
inserting the code into the computer program 112.
In step 930, the user 110 determines whether the project identified in step
908 has been completely addressed by the computer program 112. If the
project has not been completely addressed, then control flows back to step
922 to enable the user 110 to continue to generate the computer program
112 (alternatively, control flows along control line 411, which is
described below). Otherwise, generation of the computer program 112 is
complete, and flowchart 902 terminates, as indicated by step 932.
Note that all of the selected objects in the above description were of the
same object class. The present invention also supports the application of
a method to objects of different classes. In this case, the selected
dialog includes in its representation another dialog (using a Dialog type
parameter). The selected dialog operates to process objects of one class.
The other dialog operates to process objects of another class. This
approach can be readily extended to process objects of more than two
classes.
According to the invention, the user 110 may use either the dialogs alone
to generate computer programs 112 (as described above with reference to
FIG. 4), the dialogs applied to objects to generate computer programs 112
(as described above with reference to FIGS. 9A and 9B), or any combination
of these. The interaction between flowcharts 402 and 902 in FIGS. 4, 9A,
and 9B are indicated by control lines 411 and 421, although other
connectivity between flowcharts 402 and 902, so as to provide users 110
will additional flexibility with using dialogs and objects to create
computer programs 112, will be apparent to persons skilled in the relevant
art(s).
It should be understood that, while in the above description some functions
were described as being performed by an user, and others by an
administrator, in practice any step can be performed by an administrator
or an user, or by both. Accordingly, users and administrators are
collectively referred to as operators herein.
While various embodiments of the present invention have been described
above, it should be understood that they have been presented by way of
example only, and not limitation. Thus, the breadth and scope of the
present invention should not be limited by any of the above-described
exemplary embodiments, but should be defined only in accordance with the
following claims and their equivalents.
Top