Data processing: software development – installation – and managem – Software program development tool – Code generation
Reexamination Certificate
1999-05-25
2003-05-06
Chaki, Kakali (Department: 2122)
Data processing: software development, installation, and managem
Software program development tool
Code generation
C717S108000, C717S111000, C717S116000, C709S203000
Reexamination Certificate
active
06560770
ABSTRACT:
FIELD OF THE INVENTION
The present invention relates to computer systems and, more specifically, to extending the attributes of an application generated using a fourth generation programming tool.
BACKGROUND OF THE INVENTION
While computers themselves have automated many tasks that had previously been performed manually, it has only been fairly recently that the task of programming the computer has achieved some level of automation. Early computer programming languages required the programmer to manually enter all of the code of an application, usually by typing source code in a text file. While such manual code entry was tedious and error prone, it did have the advantage that virtually all aspects of the resulting applications were entirely under the control of the programmer. Programmers could modify their programs however they saw fit by simply modifying the underlying code.
Over time, techniques have been developed to automate the creation of applications. In particular, tools have been developed to allow users to design applications, and to automatically generate code that implements those applications, simply by interacting with user interface controls. Such tools are generally referred to as fourth generation (4GL) programming tools.
For example, a 4GL programming tool may present an application designer with a window that represents the interface that the to-be-generated application will display to its users. The 4GL programming tool may further present the application designer with user interface design tools that allow the application designer to visually “paint” standard user interface components onto the window. For example, the user interface design tools may allow the application designer to place check boxes, menus, dialog boxes, list boxes, and buttons onto the window, and allow the application designer to specify what should happen when the user interacts with those components.
The user may view a “property palette” for each user interface component that the user has placed on the window. The property palette lists the properties of the user interface component that can be specified by the user, and the current value of those properties. For example, a property for a button component may be “label”, where the value assigned to the label property is the text that is displayed on the button.
Once the application designer has finished designing the application, the 4GL programming tool automatically generates code for the application. The form of the code thus generated may vary from implementation to implementation. For example, the 4GL programming tool may generate machine-executable code, source code, and/or metadata. For the purpose of explanation, the term “application code” shall be used herein to refer to the data generated by a 4GL programming tool to specify the applications designed using the 4GL programming tool, regardless of the form of that data.
Frequently, the 4GL programming tool is used to generate application code that is not directly executable by a computer, but which, when executed by a particular runtime engine, implements the application that was designed using the 4GL programming tool. For example, the runtime engine reads the application code generated by the 4GL programming tool, and “executes” the application code by displaying the window previously designed by the application designer, along with all of the user interface components that were added to the window by the application designer. When the user interacts with those user interface components, the application performs the actions that the application programmer assigned to those components using the 4GL programming tool.
4GL programming tools make designing applications far easier and faster, and less error prone, than manual coding techniques. However, the ease and speed gained by 4GL programming is not without its price. In particular, the virtually unrestrained flexibility and control provided by manual coding is lost. Instead, the 4GL programming tool user is typically presented with a “canned” set of standard user-interface components. The code that actually implements those components is typically contained in a compiled library that is distributed with the 4GL programming tool, and are thus generally inaccessible to the user. Consequently, the user is limited to (1) the set of components offered by the 4GL programming tool, (2) the properties provided by those components, and (3) the functions performed by the methods provided for those components. Even slight deviations from the norm, such as presenting an oval button instead of a rectangular button, are not possible if the components provided by the 4GL programming tool do not have user-settable properties that allow the deviations. For example, for a 4GL programmer to use oval buttons, the button component provided by the 4GL programming tool would have to provide a “shape” property that may be changed from “rectangle” to “oval”. If the button component does not have a “shape” property, or if “oval” is not a value supported for the shape property, then the user cannot design applications that have oval buttons.
The attributes and behaviors of the user interface (UI) and software components that a 4GL programmer may incorporate in an application are implemented in object classes supplied in a library that is provided with the 4GL programming tool. The library is typically supplied in compiled form, so that it is not editable. When the user designs an application that uses a button, for example, the 4GL programming tool generates code which, when executed by the runtime engine, results in calls being made to methods within the “button” class in the library provided with the 4GL programming tool. If the “display” method of the button class is designed to display a rectangular button, then a rectangular button will be displayed, even if the designer would prefer an oval button.
Based on the foregoing, it is clearly desirable to provide a method and system that allows applications to be designed easily and quickly using 4GL programming tools, but which allows greater flexibility than current 4GL programming tools. In particular, it is desirable to provide a 4GL programming tool that does not restrict users to only those implementations of components that are supplied with the 4GL programming tool.
SUMMARY OF THE INVENTION
According to one aspect of the invention, a 4GL programming tool is provided that allows application designers to specify the implementation classes of the components that are used in the applications that they design using the 4GL programming tool. The implementation classes thus specified may define attributes and behaviors not supported by the corresponding component implementations provided with the 4GL programming tool. During runtime, methods in the specified implementation classes are invoked. To correctly invoke the methods of user-specified implementation classes, the interfaces of the methods must be known to the entity performing the invocations. Therefore, according to one aspect of the invention, all component implementations that are to be used by the application, including both the “standard” component implementations provided with the 4GL programming tool and the “custom” component implementations specified by the application designer, implement a common interface.
REFERENCES:
patent: 5721929 (1998-02-01), Pasquariello
patent: 5911070 (1999-06-01), Solton et al.
patent: 5960200 (1999-09-01), Eager et al.
patent: 6167563 (2000-12-01), Fontana et al.
patent: 6237135 (2001-05-01), Timbol
Mancini, L. V., “A technique for subclassing and its implementation exploiting polymorphic procedures” Software Practice & Experience, John Wiley & Sons Ltd. Chichester, GB, vol. 18, No. 4, Apr. 1988 (Apr. 1998), pp. 287-300, XP002114375 ISSN: 0038-0644. p. 294, line 9—p. 298, line 34.
Baumgartner G., et al.: “Signatures: A Language Extension for Improving Type Abstraction and Subtype Polymorphism in C++”, Software Practice and Experience, GB, John Wiley & Sons Ltd. Chichester, vol. 25, No. 8, A
Harrison Christopher J.
Saxena Sanjay
Chaki Kakali
Eichstaedt Cheryl A.
Hickman Brian D.
Hickman Palermo & Truong & Becker LLP
Kendall Chuck
LandOfFree
Extending the attributes of an application generated using a... does not yet have a rating. At this time, there are no reviews or comments for this patent.
If you have personal experience with Extending the attributes of an application generated using a..., we encourage you to share that experience with our LandOfFree.com community. Your opinion is very important and Extending the attributes of an application generated using a... will most certainly appreciate the feedback.
Profile ID: LFUS-PAI-O-3030768