WO2005078576A1 - Code generator for adding a new feature - Google Patents

Code generator for adding a new feature Download PDF

Info

Publication number
WO2005078576A1
WO2005078576A1 PCT/CA2005/000054 CA2005000054W WO2005078576A1 WO 2005078576 A1 WO2005078576 A1 WO 2005078576A1 CA 2005000054 W CA2005000054 W CA 2005000054W WO 2005078576 A1 WO2005078576 A1 WO 2005078576A1
Authority
WO
WIPO (PCT)
Prior art keywords
knowledge
rales
application
code generator
code
Prior art date
Application number
PCT/CA2005/000054
Other languages
French (fr)
Inventor
Nelson H. Lin
Original Assignee
Robocoder Corporation
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Application filed by Robocoder Corporation filed Critical Robocoder Corporation
Priority to EP05706396A priority Critical patent/EP1716484A4/en
Publication of WO2005078576A1 publication Critical patent/WO2005078576A1/en

Links

Classifications

    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F8/00—Arrangements for software engineering
    • G06F8/30—Creation or generation of source code
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00—Arrangements for program control, e.g. control units
    • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/44—Arrangements for executing specific programs
    • G06F9/451—Execution arrangements for user interfaces

Definitions

  • the present invention relates generally to the field of software development ⁇ nd, more particularly, to improvements in automatic code generation for enterprise software.
  • Automatic code generation is one approach to achieving this goal.
  • Enterprise software applications are usually comprised of millions of lines of computer code and have traditionally required teams of programmers several years to create, test and debug.
  • an automatic code generator may be used to capture knowledge and business rules for an enterprise software application and generate the millions of lines of codes within seconds in any desired computer language and for any platform.
  • An example of an automatic code generator includes GeneXus, a product of ARTech Consultores S.R.L.
  • automatic code generators which are themselves enterprise-level software applications, are developed from scratch using standard development tools and programming techniques, not using automatic code generation.
  • FIG. 1 is a block diagram of a self-generating automatic code generator, also referred to herein as a code-generating robot;
  • FIG. 2 is a user interface screen for capturing some of the dynamic knowledge required for generating itself or a different screen;
  • FIG. 3 is a user interface screen for capturing some of the dynamic rules required for the validation and organization of dynamic knowledge captured by the user interface screen of FIG. 2;
  • FIG. 4 is an entity relationship diagram showing some of the data stored and their relationships for the dynamic knowledge captured in FIG. 2;
  • FIG. 5 illustrates some of the static knowledge and rules required for the generation of computer code for a plurality of applications;
  • FIG. 6 is a user interface for the generation of computer codes based on static knowledge and static rules applied to captured dynamic knowledge;
  • FIG. 7 illustrates a process of seeding a first iteration of the code- generating robot
  • FIG. 8 illustrates a process of enhancing the first iteration of the code-generating robot
  • FIG. 9 is an example screen of an application generated with the new feature "Screen Filters” with the default filter radio button checked
  • FIG. 10 is an example screen of an application generated with the new feature "Screen Filters” with the other filter radio button checked
  • T FIG. 11 is a table with columns used for the storage of dynamic knowledge for the new feature "Screen Filters” to appear in the desired applications
  • FIG. 12 illustrates dynamic knowledge captured for the generation of the screen required to capture dynamic knowledge required for the new feature "Screen Filters”
  • FIG. 13 is a dialog for generating the screen required to capture dynamic knowledge for the new feature "Screen Filters”;
  • FIG. 14 illustrates the screen to capture dynamic knowledge required for the new feature "Screen Filters”;
  • FIG. 15 shows some of the code representing static knowledge and static rules for the generation of computer code needed for the new feature "Screen Filters”;
  • FIG. 16 illustrates the fact that a screen used to generate the new feature also enjoy the same benefit of the new feature;
  • FIG. 17 further illustrates a code- generating robot that has just generated itself with a new feature that is now also available for other applications; and
  • FIG. 18 is a flowchart of a method for application development and maintenance according to an embodiment of the invention.
  • the present invention solves the foregoing problems and disadvantages by providing a self-generating automatic code generator that maintains continuity with the enterprise applications it creates throughout development and maintenance of the applications. If a new feature is required by one application that would also by needed by the other applications within the organization, a programmer may simply add this new feature to the self-generating automatic code generator, which is itself an enterprise application, after which the self-generating automatic code generator can, within seconds, regenerate the other applications to include this new feature, including itself.
  • like reference numerals refer to like elements. For clarity, the first digit of a reference numeral indicates the figure number in which the corresponding element is first used.
  • FIG. 1 is a block diagram of a self-generating automatic code generator 100 (also referred to herein as a "code-generating robot” or simply “robot”) according to an embodiment of the invention.
  • a typical enterprise application essentially includes input, data stores and output.
  • Input data is usually captured by a screen (user interface) or by integration with other applications.
  • a set of rules must be defined and applied to the input data.
  • the output data is usually a report, a document, a file, or integration with other applications. There is usually a criteria screen for the selection of the output data.
  • a set of rules is also defined and applied to the output data to make them useful.
  • the code- generating robot 100 is, itself, an enterprise application.
  • the code-generating robot 100 includes a front-end user interface 102 for software developers to capture dynamic knowledge and dynamic rules as input required for automatic code generation.
  • the code-generating robot 100 also includes a dynamic rule layer 104 to apply dynamic rules to captured dynamic knowledge and rules.
  • the front-end user interface 102 may be displayed within the context of a standard web browser, such as Microsoft Internet ExplorerTM.
  • a standard web browser such as Microsoft Internet ExplorerTM.
  • the code-generating robot 100 includes one or more data stores 106, such as a SQL (structured query language) server, for storing and organizing the dynamic knowledge and dynamic rules captured by the front-end user interface 102.
  • the SQL server may be embodied as a standard Microsoft SQL Server or other SQL server known to those of skill in the art.
  • the code-generating robot 100 also includes a code generation rule layer 108 to apply static knowledge and static rules to stored dynamic knowledge.
  • the robot 100 includes, in one configuration, a back-end user interface 110 to generate computer code based on static knowledge and static rules applied to stored dynamic knowledge.
  • Each enterprise application has its purpose. The purpose of the code-generating robot 100 is to generate an enterprise application such as itself. Therefore, as shown in FIG. 2, the input data is the dynamic knowledge 200 required by the target enterprise application.
  • the dynamic knowledge 200 captured may include: • Screen name; • Table names to store the input data; • Column names and their structures to store the input data; • The absolute or relative positions these columns should appear on the screen; • The manner these columns should appear on the screen; • etc.
  • certain dynamic rules 300 are provided to ensure that the dynamic knowledge 200 captured is useful data and structured in a desirable manner.
  • the dynamic rules 300 may include: • Validation rules governing input data integrity, e.g., constraint rules.
  • An example of a validation rule may include "execution order entered must be positive".
  • Calculation rules performing mathematical computation to input data, e.g., computation rules.
  • Inferring rules modify or add other data based on input data, e.g., inference rules.
  • An example of an inferring rule may include "if new column entered then default new column to read only”.
  • Action rules triggers other activities based on input data, e.g., action- enabling rules.
  • An example of an action rule may be to delete all the storage of help message, heading, label, etc. associated with a column if that column is being erased from the screen to be generated.
  • FIG. 3. provides an example screen 302 showing different dynamic rules 300.
  • the knowledge and rules captured by both the application and the code-generating robot are of substantially identical types.
  • screen column name is stored as Unicode characters.
  • the application and the code-generating robot 100 employ substantially identical platforms, languages, and architectures. For example, in the depicted embodiment, the application and the code-generating robot 100 may each use Windows
  • relational data 400 may include various tables 402, such as a screen table 402a, a screen object table
  • the screen table 402a is used for capturing characteristic of a screen. It may include various columns, such as Screen Type, Table Name, Program
  • the screen object table 402b is used for capturing columns characteristic of a screen. Columns for the screen object table 402b may include Column Name, Column
  • the screen type table 402c may be used to capture name and description of each screen type. Columns for the screen type table 402c may include Screen Type Name, Screen Type Description, etc.
  • the server rule table 402d may be used to capture server side business rules. Columns within the server rule table 402d may include Rule Name, Rule Type, Execution Order, etc..
  • the server rule type table 402 may be used to capture name and description each server rule type. Columns within the server rule type table 402 may include Server Rule Type Name, Server Rule type Description.
  • the relational data 400 is being displayed by a SQL Server Manager, utility 404, which is typically included with a standard SQL server.
  • Such utilities 404 may be used in the process enterprise software development, but are not necessary for the operation of the code-generating robot 100.
  • various static universal knowledge and rules 500 may be applicable to all (or a majority of) applications.
  • the knowledge is generally framework- or platform-related, such as network connectivity, database connectivity, security, language, architecture, etc.
  • the static universal knowledge and rules 500 relate to preparing codes based on various data types specific to the database used.
  • the static universal knowledge and rules 500 are depicted within a SQL query analyzer 502, which, again, is a utility provided with a standard SQL server that may assist with enterprise software development, but is not required for the operation of the code- generating robot 100.
  • the static universal knowledge and rules 500 usually comprise the code to be generated depending on the dynamic knowledge 200 being captured.
  • the code generation rule layer 108 applies the static knowledge and rules 500 to the captured dynamic knowledge 200 and rules 300 that are stored within the data store 106.
  • the back-end user interface 110 for code generation is called upon.
  • the back-end user interface 110 displays a list of screens from which the user may select the screen (or screens) to be generated.
  • a selection mechanism 602 is provided to allow the user to decide whether the code is to be generated in the target language and platform on a test basis for further checking or directly deployed to the development environment.
  • the system proceeds to generate codes to a predefined directory for reviewing and testing only. If, however, the user selects the "deployment” option, the system proceeds to generate codes to a predefined development directory for compilation.
  • the back-end user interface 110 includes an "all screens” check box 604 that allows the user to automatically select all of the listed screens for generation. The generation process starts in response to the user selecting a "create” button 606 or the like.
  • the computer code generated is not limited to a particular user interface, network interface, security, connectivity, integration, database schema, etc. The computer code generated is also not limited to any computer language, architecture, or platform. FIG.
  • FIG. 7 is flowchart of a process for creating a code-generating robot 100 according to an embodiment of the invention.
  • the first utility that needs to be generated is the screen for capturing dynamic knowledge, as depicted in FIG. 2. Therefore, to seed the code- generating robot 100, the dynamic knowledge that should have been captured by this interface (that does not yet exist) is manually entered 702 and stored in a dynamic knowledge data store 704. The dynamic knowledge is manually entered with extreme care so that the dynamic rules required for this screen can be deferred. Thereafter, the static knowledge and static rules are manually programmed 706 to apply to the manually entered dynamic knowledge.
  • the code generator uses these knowledge and rules to generate 708 (compiles the knowledge and rules into) the very first screen 710.
  • This first screen 710 does not yet have any dynamic rules attached, and many other features may still be needed for this screen. Therefore, as shown in FIG. 8, a second screen 802 — the user interface needed to capture dynamic rules — is created by using the first screen 710 to capture the dynamic knowledge required for the second screen. This is done carefully, since no dynamic rules are available yet for the first screen 710.
  • the dynamic knowledge is stored within the dynamic knowledge store 704. Thereafter, the static knowledge and static rules are manually programmed 806 to apply to the manually entered dynamic knowledge.
  • the code generator then generates 808 target computer codes for the second screen 802.
  • the second screen 802 (an example of which is shown in FIG. 3) is available, it is used to capture the dynamic rales required for the first screen 710, and thus, the first screen 710 is enhanced.
  • the iterative process of developing more and more utilities as in FIG. 8 more and more new features can be added to the code-generating robot 100. Because the same features are available for the target applications the robot 100 generates, the reverse is also true when a new feature is required by a target application. The new feature is added to this self-generating automatic code generator 100 first. The code for the target application is then generated with the new feature in it.
  • a user wishes to add a new feature, such as a filter, to a screen.
  • the purpose of this screen filter is to allow a user to choose from a list of radio-buttons to selectively display certain items from a list of items, e.g., active vs. inactive employees in a payroll system.
  • selecting the first radio button 902 displays a list of all the active employees
  • selecting the second radio-button 1002 displays only the inactive employees.
  • a data store table 1102 called "ScreenFilter" is first created.
  • the table 1102 may include various columns 1104, such as screen filter ID 1104a, screen ID 1104b, screen filter name 1104c, screen filter description 1004d, filter clause 1104e, and filter order 1104f.
  • the screen filter ID 1104a may be used for identifying this particular screen filter in the system.
  • the screen ID 1104b relates to the particular screen this screen filter applies to.
  • the screen filter name 1104c is the unique name identifying this screen filter.
  • the screen filter description 1104d may contain description other than just a name to easily identify this screen filter upon sorting or searching.
  • the filter clause 1104e relates to the condition this screen filter becomes valid.
  • the filter order 1104f defines the order this screen filter appears with respect to other filters for the same screen.
  • the table 1102 may include additional or different information within the scope of the invention.
  • the dynamic knowledge needed for the screen "ScreenFilter” is captured using the first screen created by the code-generating robot 100.
  • the dynamic knowledge may be represented within one or more columns 1202.
  • the columns 1202 may include screen column ID 1202a, master table 1202b, column ID 1202c, column name 1202d, default value 1202e, system value 1202f, launch screen 1202g, column size 1202h, column height 1202i, and display mode 1202j, drop down key column 1202k.
  • the screen column ID 1202c relates to the column of the data store for this column.
  • the column name 1202d is the unique name referring to the column of the data store for this column.
  • the default value 1202e capture the initial displayed value for this column.
  • the system value 1202f capture the server assigned value for this column, etc..
  • Different or additional columns 1202 may be provided within the scope of the invention.
  • the code for the "ScreenFilter" screen may be generated using the depicted code-generation screen 1300.
  • the code-generation screen 1300 may include a selection mechanism 1302 for allowing the user to determine whether the code is to be generated in the target language and platform on a test basis for further checking or directly deployed to the development environment. Referring to FIG.
  • FIG. 15 illustrates the addition of the static knowledge and rules 1500 needed for the generation of codes for this new feature.
  • the static knowledge and rules is represented as program code in the C# language. However, any language could be used within the scope of the invention.
  • the next step is to generate and test the codes using salary info screen (see FIG. 9 & 10) as an example.
  • a Screen Filter Maintenance screen 1600 is used to capture dynamic knowledge for itself.
  • the dynamic knowledge t captured for itself includes the screen that refers to itself, the condition that this screen filter becomes valid, and the order this screen filter appears with respect to other screen filters for the same screen.
  • this new filter feature is now apparent as more dynamic knowledge is captured for this Screen Filter Maintenance screen 1700 itself, which is being used to generate other applications.
  • This new feature is fully utilized now in the code-generating robot generator 100. Notice not only the screen (FIG. 17) for the self- generated code generator 100 has the same features as the screen (FIG. 9 & 10) for the application it generates, they share the same look and feel, architecture, language, platform, etc.
  • FIG. 18 is a flowchart for a method 1800 for adding a new feature to an application generated by an automatic code generator. Initially, a set of knowledge and rales that define an application is captured 1802. Thereafter, code for the application is generated 1804 by providing a first automatic code generator, such as the code-generating robot 100 of FIG. 1 , with the set of knowledge and rales. A set of knowledge and rules that define a new feature to be added to the application is then captured 1806.
  • a first automatic code generator such as the code-generating robot 100 of FIG. 1
  • code for a second automatic code generator (e.g., a new version of the first automatic code generator) that supports the new feature is then generated 1808 by providing the first automatic code generator with the set of knowledge and rales defining the new feature as well as a set of knowledge and rales defining the first automatic code generator.
  • code for the application is regenerated 1810 such that the application includes the new feature by providing the second automatic code generator with the set of knowledge and rales for generating the application as well as a set of knowledge and rales for using the new feature.

Landscapes

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

Abstract

A self-generating automatic code generation system includes a user interface for capturing a set of knowledge and rules that define an application; a first automatic code generator for generating code for the application using the set of knowledge and rules; a user-interface for capturing a set of knowledge and rules that define a new feature to be added to the application; and a second automatic code generator supporting the new feature that was automatically generated by the first automatic code generator using the set of knowledge and rules defining the new feature as well as a set of knowledge and rules defining the first automatic code generator, wherein the second automatic code generator is to regenerate the code for the application such that the application includes the new feature using a set of knowledge and rules for generating the application as well as a set of knowledge and rules for using the new feature.

Description

CODE GENERATORFORADDINGANEWFEATURE
Technical Field The present invention relates generally to the field of software development ^nd, more particularly, to improvements in automatic code generation for enterprise software.
Background of the Invention Reducing development and maintenance time is an increasingly important goal for developers of enterprise software. Automatic code generation is one approach to achieving this goal. Enterprise software applications are usually comprised of millions of lines of computer code and have traditionally required teams of programmers several years to create, test and debug. Today, an automatic code generator may be used to capture knowledge and business rules for an enterprise software application and generate the millions of lines of codes within seconds in any desired computer language and for any platform. An example of an automatic code generator includes GeneXus, a product of ARTech Consultores S.R.L. Ironically, automatic code generators, which are themselves enterprise-level software applications, are developed from scratch using standard development tools and programming techniques, not using automatic code generation. This means that all the benefits attributable to automatic code generators do not apply to the development process of automatic code generators. Another deficiency of conventional automatic code generators is the discontinuity that inevitably results between development and maintenance of enterprise software. Traditionally, an automatic code generator produces computer code for a target platform based on the captured knowledge and business rules. Once the computer code is generated, programmers customize the code to fix bugs, add new features, and the like. This breaks the continuity between the enterprise software and the automatic code generator. Subsequent development or maintenance on the enterprise software must be done the traditional way without the benefit of the automatic code generator. The discontinuity problem is exacerbated where an automatic code generator is used to create several different software applications for an enterprise, all of which are subsequently modified or updated in various ways outside of the context of the automatic code generator. If a new feature is later desired for all of the software applications, t programmers must independently code the new feature into each application, thereby increasing development time and the possibility of bugs and incompatibility between applications. What is needed is a way to bring all the benefits provided by an automatic code generator to the automatic code generator, itself, so that any enterprise software applications generated thereby can always rely on the automatic code generator to regenerate any computer code that these applications require. Furthermore, what is needed is a way for programmers to add a new feature only once and have the code generator automatically supply that feature to all of the other applications. Brief Description of the Drawings Non-exhaustive embodiments of the invention are now described with reference to the figures, in which FIG. 1 is a block diagram of a self-generating automatic code generator, also referred to herein as a code-generating robot; FIG. 2 is a user interface screen for capturing some of the dynamic knowledge required for generating itself or a different screen; FIG. 3 is a user interface screen for capturing some of the dynamic rules required for the validation and organization of dynamic knowledge captured by the user interface screen of FIG. 2; FIG. 4 is an entity relationship diagram showing some of the data stored and their relationships for the dynamic knowledge captured in FIG. 2; FIG. 5 illustrates some of the static knowledge and rules required for the generation of computer code for a plurality of applications; FIG. 6 is a user interface for the generation of computer codes based on static knowledge and static rules applied to captured dynamic knowledge; FIG. 7 illustrates a process of seeding a first iteration of the code- generating robot; FIG. 8 illustrates a process of enhancing the first iteration of the code-generating robot; FIG. 9 is an example screen of an application generated with the new feature "Screen Filters" with the default filter radio button checked; FIG. 10 is an example screen of an application generated with the new feature "Screen Filters" with the other filter radio button checked; T FIG. 11 is a table with columns used for the storage of dynamic knowledge for the new feature "Screen Filters" to appear in the desired applications; FIG. 12 illustrates dynamic knowledge captured for the generation of the screen required to capture dynamic knowledge required for the new feature "Screen Filters"; FIG. 13 is a dialog for generating the screen required to capture dynamic knowledge for the new feature "Screen Filters"; FIG. 14 illustrates the screen to capture dynamic knowledge required for the new feature "Screen Filters"; FIG. 15 shows some of the code representing static knowledge and static rules for the generation of computer code needed for the new feature "Screen Filters"; FIG. 16 illustrates the fact that a screen used to generate the new feature also enjoy the same benefit of the new feature; FIG. 17 further illustrates a code- generating robot that has just generated itself with a new feature that is now also available for other applications; and FIG. 18 is a flowchart of a method for application development and maintenance according to an embodiment of the invention.
Detailed Description The present invention solves the foregoing problems and disadvantages by providing a self-generating automatic code generator that maintains continuity with the enterprise applications it creates throughout development and maintenance of the applications. If a new feature is required by one application that would also by needed by the other applications within the organization, a programmer may simply add this new feature to the self-generating automatic code generator, which is itself an enterprise application, after which the self-generating automatic code generator can, within seconds, regenerate the other applications to include this new feature, including itself. Reference is now made to the figures in which like reference numerals refer to like elements. For clarity, the first digit of a reference numeral indicates the figure number in which the corresponding element is first used. In the following description, numerous specific details of programming, software modules, user selections, network transactions, database queries, database structures, etc., are provided for a thorough understanding of the embodiments of the invention. However, those skilled in the art will recognize that the invention can be practiced without one or more of the specific details, or with other methods, components, materials, etc. In some cases, well-known structures, materials, or operations are not shown or described in detail in order to avoid obscuring aspects of the invention. Furthermore, the described features, structures, or characteristics may be combined in any suitable manner in one or more embodiments. FIG. 1 is a block diagram of a self-generating automatic code generator 100 (also referred to herein as a "code-generating robot" or simply "robot") according to an embodiment of the invention. A typical enterprise application essentially includes input, data stores and output. Input data is usually captured by a screen (user interface) or by integration with other applications. In order to make sure that the input data are stored properly, a set of rules must be defined and applied to the input data. The output data is usually a report, a document, a file, or integration with other applications. There is usually a criteria screen for the selection of the output data. A set of rules is also defined and applied to the output data to make them useful. As shown in FIG. 1, the code- generating robot 100 is, itself, an enterprise application. In one embodiment, the code-generating robot 100 includes a front-end user interface 102 for software developers to capture dynamic knowledge and dynamic rules as input required for automatic code generation. The code-generating robot 100 also includes a dynamic rule layer 104 to apply dynamic rules to captured dynamic knowledge and rules. As illustrated, the front-end user interface 102, as well as various other screens depicted in succeeding figures, may be displayed within the context of a standard web browser, such as Microsoft Internet Explorer™. However, those of skill in the art will recognize that the present invention is not limited to web-based implementations. In the depicted embodiment, the code-generating robot 100 includes one or more data stores 106, such as a SQL (structured query language) server, for storing and organizing the dynamic knowledge and dynamic rules captured by the front-end user interface 102. In one embodiment, the SQL server may be embodied as a standard Microsoft SQL Server or other SQL server known to those of skill in the art. As further illustrated in FIG. 1, the code-generating robot 100 also includes a code generation rule layer 108 to apply static knowledge and static rules to stored dynamic knowledge. Finally, the robot 100 includes, in one configuration, a back-end user interface 110 to generate computer code based on static knowledge and static rules applied to stored dynamic knowledge. Each enterprise application has its purpose. The purpose of the code-generating robot 100 is to generate an enterprise application such as itself. Therefore, as shown in FIG. 2, the input data is the dynamic knowledge 200 required by the target enterprise application. As an example, for a code-generating robot 100 to generate a screen 202 for a target enterprise application, including itself, the dynamic knowledge 200 captured may include: • Screen name; • Table names to store the input data; • Column names and their structures to store the input data; • The absolute or relative positions these columns should appear on the screen; • The manner these columns should appear on the screen; • etc. Referring to FIG. 3, depending on the dynamic knowledge 200 captured, certain dynamic rules 300 are provided to ensure that the dynamic knowledge 200 captured is useful data and structured in a desirable manner. Various types of dynamic rules 300 may be captured. For instance, the dynamic rules 300 may include: • Validation rules governing input data integrity, e.g., constraint rules. An example of a validation rule may include "execution order entered must be positive". • Calculation rules performing mathematical computation to input data, e.g., computation rules. An example of a calculation rule may include "total invoice amount = sales amount + sales tax". • Inferring rules modify or add other data based on input data, e.g., inference rules. An example of an inferring rule may include "if new column entered then default new column to read only". • Action rules triggers other activities based on input data, e.g., action- enabling rules. An example of an action rule may be to delete all the storage of help message, heading, label, etc. associated with a column if that column is being erased from the screen to be generated. FIG. 3. provides an example screen 302 showing different dynamic rules 300. However, those of skill in the art will recognize that a wide variety of other rules 300 may be provided within the scope of the invention. Because the code-generating robot 100 is to generate an enterprise application such as itself, several conditions should be satisfied, although not all of the following conditions may be satisfied in every embodiment. First, the application and the code-generating robot
100 employ substantially identical (i.e., similar, compatible, interoperable) user interfaces to capture knowledge and rules. For instance, Screen Columns Maintenance screen Fig.
200 that capture dynamic knowledge for screen columns has essentially the same user interfaces as the Server Rules Maintenance screen Fig. 300 that capture dynamic knowledge for screen business rules. Second, the knowledge and rules captured by both the application and the code- generating robot are of substantially identical types. As an example, screen column name is stored as Unicode characters. Third, the application and the code-generating robot 100 employ substantially identical platforms, languages, and architectures. For example, in the depicted embodiment, the application and the code-generating robot 100 may each use Windows
Server 2003 as the platform, C# as the computer language, and Microsoft Dot Net
Framework as the architecture. Finally, the application and the code generators employ substantially identical data stores and data relationships. For example, SQL relational databases could be used within an embodiment of the invention. Referring to FIG. 4, the captured dynamic knowledge 200 and rules 300 are then stored as relational data 400 in an SQL Server (not shown). As illustrated, the relational data 400 may include various tables 402, such as a screen table 402a, a screen object table
402b, a screen type table 402c, a server rule table 402d, and a server rule type table 402e. In one embodiment, the screen table 402a is used for capturing characteristic of a screen. It may include various columns, such as Screen Type, Table Name, Program
Name, etc. The screen object table 402b is used for capturing columns characteristic of a screen. Columns for the screen object table 402b may include Column Name, Column
Type, Column Size, etc.. The screen type table 402c may be used to capture name and description of each screen type. Columns for the screen type table 402c may include Screen Type Name, Screen Type Description, etc. In the illustrated embodiment, the server rule table 402d may be used to capture server side business rules. Columns within the server rule table 402d may include Rule Name, Rule Type, Execution Order, etc.. Finally, the server rule type table 402 may be used to capture name and description each server rule type. Columns within the server rule type table 402 may include Server Rule Type Name, Server Rule type Description. In the depicted embodiment of FIG. 4, the relational data 400 is being displayed by a SQL Server Manager, utility 404, which is typically included with a standard SQL server. Such utilities 404 may be used in the process enterprise software development, but are not necessary for the operation of the code-generating robot 100. Referring to FIG. 5, various static universal knowledge and rules 500 may be applicable to all (or a majority of) applications. The knowledge is generally framework- or platform-related, such as network connectivity, database connectivity, security, language, architecture, etc. For example, in the illustrated embodiment, the static universal knowledge and rules 500 relate to preparing codes based on various data types specific to the database used. The static universal knowledge and rules 500 are depicted within a SQL query analyzer 502, which, again, is a utility provided with a standard SQL server that may assist with enterprise software development, but is not required for the operation of the code- generating robot 100. The static universal knowledge and rules 500 usually comprise the code to be generated depending on the dynamic knowledge 200 being captured. As explained with reference to FIG. 1, the code generation rule layer 108 applies the static knowledge and rules 500 to the captured dynamic knowledge 200 and rules 300 that are stored within the data store 106. As shown in FIG. 6, when a user is ready to generate the computer code required for the target application, including the code- generating robot 100 itself, the back-end user interface 110 for code generation is called upon. The back-end user interface 110 displays a list of screens from which the user may select the screen (or screens) to be generated. i In one embodiment, a selection mechanism 602 is provided to allow the user to decide whether the code is to be generated in the target language and platform on a test basis for further checking or directly deployed to the development environment. When a user selects the "test" option, the system proceeds to generate codes to a predefined directory for reviewing and testing only. If, however, the user selects the "deployment" option, the system proceeds to generate codes to a predefined development directory for compilation. In one embodiment, the back-end user interface 110 includes an "all screens" check box 604 that allows the user to automatically select all of the listed screens for generation. The generation process starts in response to the user selecting a "create" button 606 or the like. The computer code generated is not limited to a particular user interface, network interface, security, connectivity, integration, database schema, etc. The computer code generated is also not limited to any computer language, architecture, or platform. FIG. 7 is flowchart of a process for creating a code-generating robot 100 according to an embodiment of the invention. Those of skill in the art will recognize that the code- generating robot 100 cannot generate itself when it does not initially exist. Accordingly, the process begins with seeding. The first utility that needs to be generated is the screen for capturing dynamic knowledge, as depicted in FIG. 2. Therefore, to seed the code- generating robot 100, the dynamic knowledge that should have been captured by this interface (that does not yet exist) is manually entered 702 and stored in a dynamic knowledge data store 704. The dynamic knowledge is manually entered with extreme care so that the dynamic rules required for this screen can be deferred. Thereafter, the static knowledge and static rules are manually programmed 706 to apply to the manually entered dynamic knowledge. Using these knowledge and rules, the code generator generates 708 (compiles the knowledge and rules into) the very first screen 710. This first screen 710 does not yet have any dynamic rules attached, and many other features may still be needed for this screen. Therefore, as shown in FIG. 8, a second screen 802 — the user interface needed to capture dynamic rules — is created by using the first screen 710 to capture the dynamic knowledge required for the second screen. This is done carefully, since no dynamic rules are available yet for the first screen 710. f As before, the dynamic knowledge is stored within the dynamic knowledge store 704. Thereafter, the static knowledge and static rules are manually programmed 806 to apply to the manually entered dynamic knowledge. Using these knowledge and rules, the code generator then generates 808 target computer codes for the second screen 802. When the second screen 802 (an example of which is shown in FIG. 3) is available, it is used to capture the dynamic rales required for the first screen 710, and thus, the first screen 710 is enhanced. By the iterative process of developing more and more utilities as in FIG. 8, more and more new features can be added to the code-generating robot 100. Because the same features are available for the target applications the robot 100 generates, the reverse is also true when a new feature is required by a target application. The new feature is added to this self-generating automatic code generator 100 first. The code for the target application is then generated with the new feature in it. An example of the foregoing process is now described with reference to FIGs. 9- 17. Suppose that a user wishes to add a new feature, such as a filter, to a screen. The purpose of this screen filter is to allow a user to choose from a list of radio-buttons to selectively display certain items from a list of items, e.g., active vs. inactive employees in a payroll system. As illustrated in FIG. 9, selecting the first radio button 902 displays a list of all the active employees, while, as shown in FIG. 10, selecting the second radio-button 1002 displays only the inactive employees. Referring to FIG. 11, to enable this feature for one or more target applications, such as the one depicted in FIGs. 9 and 10, as well as for the code- generating robot 100 itself, a data store table 1102 called "ScreenFilter" is first created. The table 1102 may include various columns 1104, such as screen filter ID 1104a, screen ID 1104b, screen filter name 1104c, screen filter description 1004d, filter clause 1104e, and filter order 1104f. The screen filter ID 1104a may be used for identifying this particular screen filter in the system. The screen ID 1104b relates to the particular screen this screen filter applies to. The screen filter name 1104c is the unique name identifying this screen filter. The screen filter description 1104d may contain description other than just a name to easily identify this screen filter upon sorting or searching. The filter clause 1104e relates to the condition this screen filter becomes valid. Finally, the filter order 1104f defines the order this screen filter appears with respect to other filters for the same screen. Of course, the table 1102 may include additional or different information within the scope of the invention. Thereafter, as depicted in FIG. 12, the dynamic knowledge needed for the screen "ScreenFilter" is captured using the first screen created by the code-generating robot 100. The dynamic knowledge may be represented within one or more columns 1202. For example, the columns 1202 may include screen column ID 1202a, master table 1202b, column ID 1202c, column name 1202d, default value 1202e, system value 1202f, launch screen 1202g, column size 1202h, column height 1202i, and display mode 1202j, drop down key column 1202k. The screen column ID 1202c relates to the column of the data store for this column. The column name 1202d is the unique name referring to the column of the data store for this column. The default value 1202e capture the initial displayed value for this column. The system value 1202f capture the server assigned value for this column, etc.. Different or additional columns 1202 may be provided within the scope of the invention. As shown in FIG. 13, the code for the "ScreenFilter" screen may be generated using the depicted code-generation screen 1300. As previously noted, the code-generation screen 1300 may include a selection mechanism 1302 for allowing the user to determine whether the code is to be generated in the target language and platform on a test basis for further checking or directly deployed to the development environment. Referring to FIG. 14, note that the new feature "Screen Filter" is not available for the newly generated screen which is used to capture dynamic knowledge for screen filters. As depicted in FIG. 14, this screen is now available to capture dynamic knowledge for all screen filters for selected screens. The "salary" screen is used as an example to demonstrate the knowledge captured. Note that there is no screen filter yet for this screen. FIG. 15 illustrates the addition of the static knowledge and rules 1500 needed for the generation of codes for this new feature. In the illustrated embodiment, the static knowledge and rules is represented as program code in the C# language. However, any language could be used within the scope of the invention. Referring to FIG. 16, the next step is to generate and test the codes using salary info screen (see FIG. 9 & 10) as an example. When satisfied, a Screen Filter Maintenance screen 1600 is used to capture dynamic knowledge for itself. The dynamic knowledge t captured for itself includes the screen that refers to itself, the condition that this screen filter becomes valid, and the order this screen filter appears with respect to other screen filters for the same screen. As shown in FIG. 17, this new filter feature is now apparent as more dynamic knowledge is captured for this Screen Filter Maintenance screen 1700 itself, which is being used to generate other applications. This new feature is fully utilized now in the code-generating robot generator 100. Notice not only the screen (FIG. 17) for the self- generated code generator 100 has the same features as the screen (FIG. 9 & 10) for the application it generates, they share the same look and feel, architecture, language, platform, etc. FIG. 18 is a flowchart for a method 1800 for adding a new feature to an application generated by an automatic code generator. Initially, a set of knowledge and rales that define an application is captured 1802. Thereafter, code for the application is generated 1804 by providing a first automatic code generator, such as the code-generating robot 100 of FIG. 1 , with the set of knowledge and rales. A set of knowledge and rules that define a new feature to be added to the application is then captured 1806. In one embodiment, code for a second automatic code generator (e.g., a new version of the first automatic code generator) that supports the new feature is then generated 1808 by providing the first automatic code generator with the set of knowledge and rales defining the new feature as well as a set of knowledge and rales defining the first automatic code generator. Finally, code for the application is regenerated 1810 such that the application includes the new feature by providing the second automatic code generator with the set of knowledge and rales for generating the application as well as a set of knowledge and rales for using the new feature. While specific embodiments and applications of the present invention have been illustrated and described, it is to be understood that the invention is not limited to the precise configuration and components disclosed herein. Various modifications, changes, and variations apparent to those of skill in the art may be made in the arrangement, operation, and details of the methods and systems of the present invention disclosed herein without departing from the spirit and scope of the present invention.

Claims

1. A computer-implemented method for adding a new feature to an application generated by an automatic code generator comprising: capturing a set of knowledge and rales that define the application; generating codes for the application by providing a first automatic code generator with the set of knowledge and rales; capturing a set of knowledge and rales that define a new feature to be added to the application; generating codes for a second automatic code generator that supports the new feature by providing the first automatic code generator with the set of knowledge and rules defining the new feature as well as a set of knowledge and rales defining the first automatic code generator; and regenerating the code for the application such that the application includes the new feature by providing the second automatic code generator with the set of knowledge and rales for generating the application as well as a set of knowledge and rales for using the new feature.
2. The method of claim 1, wherein the application and the code generators employ substantially identical user interfaces to capture knowledge and rules.
3. The method of claim 2, wherein the knowledge and rales captured by both the application and the code generator are of substantially identical types.
4. The method of claim 1, wherein the application and the code generators employ substantially identical platforms, languages, and architectures.
5. The method of claim 1, wherein the application and the code generators employ substantially identical data stores and data relationships.
6. The method of claim 1, wherein the application and the code generators employ substantially identical user interfaces, platforms, languages, and architectures, data stores, and data relationships.
7. The method of claim 1, wherein the first code generator is a subsequent iteration of an earlier code generator automatically generated by the earlier code generator.
8. The method of claim 1 , further comprising: regenerating codes for a second application such that the second application includes the new feature by providing the second automatic code generator with a set of knowledge and rales for generating the second application as well as a set of knowledge and rales for using the new feature.
9. The method of claim 1, wherein the rales comprise at least one of: validation rules governing input data; calculation rales for performing mathematical calculations on input data; inference rales for modifying or adding other data based on input data; and action rales for triggering actions based on input data.
10. The method of claim 1, further comprising storing captured rales and knowledge within a relational database.
11. A self-generating automatic code generation system comprising: a user interface for capturing a set of knowledge and rales that define an application; a first automatic code generator for generating codes for the application using the set of knowledge and rules; a user-interface for capturing a set of knowledge and rules that define a new feature to be added to the application; and a second automatic code generator that was automatically generated by the first automatic code generator using the set of knowledge and rules defining the new feature as well as a set of knowledge and rales defining the first automatic code generator, wherein the second automatic code generator is to regenerate the code for the application such that the application includes the new feature using the set of knowledge and rales for generating the application as well as a set of knowledge and rales for using the new feature.
12. The system of claim 11, wherein the application and the code generators employ substantially identical user interfaces to capture knowledge and rales.
13. The system of claim 12, wherein the knowledge and rales captured by both the application and the code generator are of substantially identical types.
14. The system of claim 11, wherein the application and the code generators employ substantially identical platforms, languages, and architectures.
15. The system of claim 11, wherein the application and the code generators employ substantially identical data stores and data relationships.
16. The system of claim 11, wherein the application and the code generators employ substantially identical user interfaces, platforms, languages, and architectures, data stores, and data relationships.
17. The system of claim 11, wherein the first code generator is a subsequent iteration of an earlier code generator automatically generated by the earlier code generator.
18. The system of claim 11, wherein the second code generator is to regenerate code for a second application such that the second application includes the new feature using a set of knowledge and rales for generating the second application as well as a set of knowledge and rales for using the new feature.
19. The system of claim 11 , wherein the rules comprise at least one of: validation rales governing input data; calculation rales for performing mathematical calculations on input data; inference rules for modifying or adding other data based on input data; and action rules for triggering actions based on input data.
20. The system of claim 11, further comprising a relational database for storing captured rales and knowledge.
21. A computer program product comprising program code for performing a method for adding a new feature to an application generated by an automatic code generator comprising: program code for capturing a set of knowledge and rales that define the application; program code for generating codes for the application by providing a first automatic code generator with the set of knowledge and rales; program code for capturing a set of knowledge and rules that define a new feature to be added to the application; program code for generating codes for a second automatic code generator that supports the new feature by providing the first automatic code generator with the set of knowledge and rales defining the new feature as well as a set of knowledge and rules defining the first automatic code generator; and program code for regenerating the code for the application such that the application includes the new feature by providing the second automatic code generator with the set of knowledge and rales for generating the application as well as a set of knowledge and rales for using the new feature.
22. The computer program product of claim 21, wherein the application and the code generators employ substantially identical user interfaces to capture knowledge and rules.
23. The computer program product of claim 22, wherein the knowledge and rales captured by both the application and the code generator are of substantially identical types.
24. The computer program product of claim 21, wherein the application and the code generators employ substantially identical platforms, languages, and architectures.
25. The computer program product of claim 21, wherein the application and the code generators employ substantially identical data stores and data relationships.
26. The computer program product of claim 21, wherein the application and the code generators employ substantially identical user interfaces, platforms, languages, and architectures, data stores, and data relationships.
27. The computer program product of claim 21, wherein the first code generator is a subsequent iteration of an earlier code generator automatically generated by the earlier code generator.
28. The computer program product of claim 21, further comprising: program code for regenerating codes for a second application such that the second application includes the new feature by providing the second automatic code generator with a set of knowledge and rales for generating the second application as well as a set of knowledge and rules for using the new feature.
29. The computer program product of claim 21, wherein the rules comprise at least one of: validation rales governing input data; calculation rales for performing mathematical calculations on input data; inference rales for modifying or adding other data based on input data; and action rales for triggering actions based on input data.
30. The computer program product of claim 21, further comprising program code for storing captured rales and knowledge within a relational database.
31. A self-generating automatic code generator comprising: a front-end user interface to capture dynamic knowledge and rales; a dynamic rule layer to apply the dynamic rales to the dynamic knowledge; a data store for storing the dynamic knowledge and rales after application of the dynamic rales by the dynamic rale layer; a code generation rale layer to apply static knowledge and rules to the stored dynamic knowledge; and a back-end user interface to generate new computer code for the front-end user interface based on the static knowledge and static rales applied to the stored dynamic knowledge.
32. A method for creating a self-generating automatic code generator comprising: manually programming dynamic knowledge for a user first interface for capturing dynamic knowledge; manually programming static knowledge and rules to be applied to the manually- programmed dynamic knowledge; generating codes for the first user interface using the manually-programmed static knowledge and static rales applied to the manually-programmed dynamic knowledge; using the first user interface to capture dynamic knowledge for a second user interface for capturing dynamic rules; manually programming static knowledge and rules to be applied to the manually- programmed dynamic knowledge for the second user interface; generating codes for the second user interface using the manually-programmed static knowledge and static rales for the second user interface applied to the manually- programmed dynamic knowledge for the second user interface; using the first and second user interfaces to capture dynamic knowledge and rules, respectively, for a third user interface for the automatic code generator; and automatically generating codes for the automatic code generator using the captured dynamic knowledge and rales.
PCT/CA2005/000054 2004-02-18 2005-01-18 Code generator for adding a new feature WO2005078576A1 (en)

Priority Applications (1)

Application Number Priority Date Filing Date Title
EP05706396A EP1716484A4 (en) 2004-02-18 2005-01-18 Code generator for adding a new feature

Applications Claiming Priority (2)

Application Number Priority Date Filing Date Title
US10/781,229 2004-02-18
US10/781,229 US6876314B1 (en) 2004-02-18 2004-02-18 Self-generating automatic code generator

Publications (1)

Publication Number Publication Date
WO2005078576A1 true WO2005078576A1 (en) 2005-08-25

Family

ID=34377781

Family Applications (1)

Application Number Title Priority Date Filing Date
PCT/CA2005/000054 WO2005078576A1 (en) 2004-02-18 2005-01-18 Code generator for adding a new feature

Country Status (4)

Country Link
US (1) US6876314B1 (en)
EP (1) EP1716484A4 (en)
CA (1) CA2492761A1 (en)
WO (1) WO2005078576A1 (en)

Families Citing this family (39)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
JP2005196291A (en) * 2003-12-26 2005-07-21 Fujitsu Ltd User interface application development program and development device
US7693918B2 (en) * 2005-03-28 2010-04-06 Microsoft Corporation Rapid prototyping, generating and dynamically modifying a schema representing a database
US20060288326A1 (en) * 2005-05-25 2006-12-21 Honeywell International Inc. Domain modeling system and method
US8589869B2 (en) * 2006-09-07 2013-11-19 Wolfram Alpha Llc Methods and systems for determining a formula
US8527939B2 (en) * 2006-09-14 2013-09-03 Sap Ag GUI modeling of knowledge base in a modeling environment
US8015506B2 (en) * 2006-09-22 2011-09-06 Microsoft Corporation Customizing a menu in a discovery interface
US8635521B2 (en) * 2006-09-22 2014-01-21 Microsoft Corporation Customizing applications in a discovery interface
US8112714B2 (en) * 2006-09-22 2012-02-07 Microsoft Corporation Customizing application page loading in a discovery interface
US8479283B2 (en) * 2006-11-28 2013-07-02 Microsoft Corporation Generating security validation code automatically
US20080178125A1 (en) * 2007-01-23 2008-07-24 Microsoft Corporation Providing dynamic content in a user interface in an application
US8046742B1 (en) * 2007-02-02 2011-10-25 Sandia Corporation Self-assembling software generator
US20080235658A1 (en) * 2007-03-21 2008-09-25 Asaf Adi Code generation for real-time event processing
US8381113B2 (en) * 2007-04-06 2013-02-19 Microsoft Corporation Metadata-driven automatic UI code generation
US8020144B2 (en) * 2007-06-29 2011-09-13 Microsoft Corporation Metadata-based application deployment
US8200604B2 (en) 2007-06-29 2012-06-12 Microsoft Corporation Multi-platform business calculation rule language and execution environment
US8291374B2 (en) * 2007-11-05 2012-10-16 Cullum Owen H G System and method for generating modified source code based on change-models
US9323938B2 (en) * 2007-12-31 2016-04-26 Enterra Solutions, Llc Holistic XACML and obligation code automatically generated from ontologically defined rule set
US8656349B2 (en) * 2008-03-07 2014-02-18 Sap Ag Systems and methods for template reverse engineering
US20100198844A1 (en) * 2009-01-30 2010-08-05 Thales-Raytheon Systems Company, LLC Automatic Code Generation
US8448132B2 (en) * 2009-05-07 2013-05-21 Sap Ag Systems and methods for modifying code generation templates
US8788524B1 (en) 2009-05-15 2014-07-22 Wolfram Alpha Llc Method and system for responding to queries in an imprecise syntax
US8601015B1 (en) 2009-05-15 2013-12-03 Wolfram Alpha Llc Dynamic example generation for queries
US8484015B1 (en) 2010-05-14 2013-07-09 Wolfram Alpha Llc Entity pages
US8812298B1 (en) 2010-07-28 2014-08-19 Wolfram Alpha Llc Macro replacement of natural language input
US9069814B2 (en) 2011-07-27 2015-06-30 Wolfram Alpha Llc Method and system for using natural language to generate widgets
US9734252B2 (en) 2011-09-08 2017-08-15 Wolfram Alpha Llc Method and system for analyzing data using a query answering system
US9851950B2 (en) 2011-11-15 2017-12-26 Wolfram Alpha Llc Programming in a precise syntax using natural language
US9632754B2 (en) 2012-07-06 2017-04-25 International Business Machines Corporation Auto generation and linkage of source code to test cases
US9405424B2 (en) 2012-08-29 2016-08-02 Wolfram Alpha, Llc Method and system for distributing and displaying graphical items
US9684491B2 (en) 2013-04-30 2017-06-20 Wal-Mart Stores, Inc. Annotation-based item description
US20160188302A1 (en) * 2014-12-30 2016-06-30 Randy Fredrick Automatic generation of metadata-based cross-platform mobile applications
US10496529B1 (en) * 2018-04-18 2019-12-03 Palantir Technologies Inc. Data unit test-based data management system
US11132185B2 (en) 2018-08-07 2021-09-28 Microsoft Technology Licensing, Llc Embedding of multiple versions in monolithic applications during compilation
JP7310943B2 (en) * 2020-02-12 2023-07-19 日本電信電話株式会社 Program generation device, program generation method and program
US11334347B2 (en) 2020-05-04 2022-05-17 International Business Machines Corporation Cognitive build recovery from inter-code commit issues
US11288153B2 (en) 2020-06-18 2022-03-29 Bank Of America Corporation Self-healing computing device
US11807240B2 (en) 2020-06-26 2023-11-07 Toyota Research Institute, Inc. Methods and systems for evaluating vehicle behavior
US11656855B2 (en) 2021-06-14 2023-05-23 International Business Machines Corporation Identify, suggest, and auto-implement best practices for requirement specific software development
US11971805B2 (en) 2021-10-08 2024-04-30 International Business Machines Corporation Intelligent automated feature toggle system using annotations

Citations (3)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US6658579B1 (en) * 2000-05-20 2003-12-02 Equipe Communications Corporation Network device with local timing systems for automatic selection between redundant, synchronous central timing systems
US6671699B1 (en) * 2000-05-20 2003-12-30 Equipe Communications Corporation Shared database usage in network devices
US20040015809A1 (en) * 2001-05-18 2004-01-22 Doreen Yining Cheng Code generation for integrating devices into a middleware framework

Family Cites Families (38)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US4796179A (en) 1986-08-20 1989-01-03 Integrated Systems, Inc. Multirate real time control system code generator
JPH0731606B2 (en) 1988-09-20 1995-04-10 ディジタル イクイプメント コーポレーション Apparatus and method for generic code sharing for digital data processing system
US5187788A (en) 1989-05-01 1993-02-16 The United States Of America As Represented By The Secretary Of The Air Force Graphics system for automatic computer code generation
US5159687A (en) 1989-11-14 1992-10-27 Caseworks, Inc. Method and apparatus for generating program code files
NZ236299A (en) 1989-11-30 1995-07-26 Seer Technologies Inc Software distribution from central database to computers in network
US5699310A (en) * 1990-06-29 1997-12-16 Dynasty Technologies, Inc. Method and apparatus for a fully inherited object-oriented computer system for generating source code from user-entered specifications
JPH0778742B2 (en) 1992-08-12 1995-08-23 インターナショナル・ビジネス・マシーンズ・コーポレイション Computer program language conversion device and method thereof
WO1995003586A1 (en) 1993-07-21 1995-02-02 Persistence Software, Inc. Method and apparatus for generation of code for mapping relational data to objects
CA2134059C (en) 1993-10-29 2009-01-13 Charles Simonyi Method and system for generating a computer program
US5612866A (en) 1994-06-24 1997-03-18 Integrated Systems, Inc. Code generation system to construct an asynchronous real-time controller for a real-time system
US5555367A (en) 1994-09-30 1996-09-10 General Electric Company Method and system for generating computer programs for queries formed by manipulating object-oriented diagrams
US5590331A (en) 1994-12-23 1996-12-31 Sun Microsystems, Inc. Method and apparatus for generating platform-standard object files containing machine-independent code
WO1997008634A1 (en) 1995-08-23 1997-03-06 International Business Machines Corporation Method and computer system for generating process management computer programs for process models
US5815717A (en) * 1995-10-27 1998-09-29 Authorgenics, Inc. Application program and documentation generator system and method
WO1997035254A1 (en) 1996-03-19 1997-09-25 Massachusetts Institute Of Technology Computer system and computer implemented process for representing software system descriptions and for generating executable computer programs and computer system configurations from software system descriptions
US6113649A (en) 1996-03-27 2000-09-05 International Business Machines Corporation Object representation of program and script components
US5875333A (en) 1996-06-07 1999-02-23 Electronic Data Systems Corporation Automatically generating source code for relating a dialog interface with a business object in a computing application
US5966533A (en) 1996-06-11 1999-10-12 Excite, Inc. Method and system for dynamically synthesizing a computer program by differentially resolving atoms based on user context data
AU5657298A (en) 1996-11-27 1998-06-22 Sony Europa B.V. Data communication method using typed continuation
US5933139A (en) 1997-01-31 1999-08-03 Microsoft Corporation Method and apparatus for creating help functions
US5978581A (en) 1997-12-02 1999-11-02 Electronic Data Systems Corporation Object-oriented code generation system and method
US6346945B1 (en) 1998-12-28 2002-02-12 Klocwork Solutions Method and apparatus for pattern-based flowcharting of source code
JP3765949B2 (en) 1999-02-17 2006-04-12 富士通株式会社 Object-oriented software development support apparatus and development support method
US6199195B1 (en) 1999-07-08 2001-03-06 Science Application International Corporation Automatically generated objects within extensible object frameworks and links to enterprise resources
EP1208512A1 (en) 1999-08-16 2002-05-29 Versata, Inc. Business rules automation in database application development and maintenance
US6487713B1 (en) 1999-09-24 2002-11-26 Phoenix Technologies Ltd. Software development system that presents a logical view of project components, facilitates their selection, and signals missing links prior to compilation
EP1122640A1 (en) 2000-01-31 2001-08-08 BRITISH TELECOMMUNICATIONS public limited company Apparatus for automatically generating source code
AU2001243371A1 (en) 2000-03-02 2001-09-12 Wind River Systems, Inc. System and method for a command structure representation
US6631519B1 (en) 2000-03-30 2003-10-07 Microsoft Corporation Automated schema and interface generation
US6681383B1 (en) 2000-04-04 2004-01-20 Sosy, Inc. Automatic software production system
FR2812479B1 (en) 2000-07-28 2003-01-31 Airsys Atm S A UNIVERSAL COMPUTER CODE GENERATOR
DE10057575A1 (en) 2000-11-20 2002-05-29 Andreas Foltinek Method for automatic software regeneration applies an abstract model to the properties of an application made possible by software converting these into software mechanically.
US20020178434A1 (en) * 2001-02-22 2002-11-28 Fox Gary L. Apparatus and method for automatic source code generation in a process control environment
JP2003005966A (en) 2001-06-25 2003-01-10 Mitsubishi Electric Corp Device for automatically generating program
US20030026143A1 (en) 2001-08-03 2003-02-06 Brennan Declan M. Method for automating the construction of data stores for storing complex relational and hierarchical data and optimising the access and update of the data therein method for defining look and feel of a user interface obviating the requirement to write programming language code
US20030084423A1 (en) 2001-10-26 2003-05-01 Dai Clegg Automatic source code generation
US20030149958A1 (en) 2002-02-06 2003-08-07 Shumeet Baluja Automatic code generation for applications which run on common platforms
US7249345B2 (en) 2002-02-28 2007-07-24 Hewlett-Packard Development Company, L.P. Method and system for automatically generating source code based on a mark-up language message definition

Patent Citations (3)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US6658579B1 (en) * 2000-05-20 2003-12-02 Equipe Communications Corporation Network device with local timing systems for automatic selection between redundant, synchronous central timing systems
US6671699B1 (en) * 2000-05-20 2003-12-30 Equipe Communications Corporation Shared database usage in network devices
US20040015809A1 (en) * 2001-05-18 2004-01-22 Doreen Yining Cheng Code generation for integrating devices into a middleware framework

Non-Patent Citations (1)

* Cited by examiner, † Cited by third party
Title
See also references of EP1716484A4 *

Also Published As

Publication number Publication date
CA2492761A1 (en) 2005-08-18
US6876314B1 (en) 2005-04-05
EP1716484A4 (en) 2007-08-01
EP1716484A1 (en) 2006-11-02

Similar Documents

Publication Publication Date Title
US6876314B1 (en) Self-generating automatic code generator
US8166347B2 (en) Automatic testing for dynamic applications
US8010946B2 (en) Apparatus for analysing and organizing artifacts in a software application
US8732656B2 (en) Development environment for managing database aware software projects
US8245186B2 (en) Techniques for offering and applying code modifications
US7913230B2 (en) Computer-implemented methods and systems for generating software testing documentation and test results management system using same
US8881105B2 (en) Test case manager
AU2005203508B2 (en) System and method for selecting test case execution behaviors for reproducible test automation
US20060015839A1 (en) Development of software systems
CN103744680B (en) Method and device for business process processing
US20120084770A1 (en) Installing Analytical Content
US20120110560A1 (en) Data type provider for a web semantic store
US20120124550A1 (en) Facilitating database application code translation from a first application language to a second application language
Robbes et al. Characterizing and understanding development sessions
US20050060685A1 (en) Program generator
EP1660995A2 (en) Information system development
JP3540241B2 (en) Application startup menu definition file generation device and application startup menu generation device
Rubarth First Steps in SAP ABAP
Markandeya et al. Migration Using Batch Input Session and Call Transaction Methods
Krishnan Oracle ADF 11gR2 development beginner's guide
Roberts et al. ATI
Haralabidis Oracle JDeveloper 11gR2 Cookbook
Myatt Creating Visual Web Applications: JSF, Ajax, and Data Binding
Pawlan Writing Enterprise Applications with Java™ 2 SDK, Enterprise Edition
Harper PL/SQL unit testing

Legal Events

Date Code Title Description
AK Designated states

Kind code of ref document: A1

Designated state(s): AE AG AL AM AT AU AZ BA BB BG BR BW BY BZ CA CH CN CO CR CU CZ DE DK DM DZ EC EE EG ES FI GB GD GE GH GM HR HU ID IL IN IS JP KE KG KP KR KZ LC LK LR LS LT LU LV MA MD MG MK MN MW MX MZ NA NI NO NZ OM PG PH PL PT RO RU SC SD SE SG SK SL SY TJ TM TN TR TT TZ UA UG US UZ VC VN YU ZA ZM ZW

AL Designated countries for regional patents

Kind code of ref document: A1

Designated state(s): GM KE LS MW MZ NA SD SL SZ TZ UG ZM ZW AM AZ BY KG KZ MD RU TJ TM AT BE BG CH CY CZ DE DK EE ES FI FR GB GR HU IE IS IT LT LU MC NL PL PT RO SE SI SK TR BF BJ CF CG CI CM GA GN GQ GW ML MR NE SN TD TG

121 Ep: the epo has been informed by wipo that ep was designated in this application
WWE Wipo information: entry into national phase

Ref document number: 2005706396

Country of ref document: EP

WWE Wipo information: entry into national phase

Ref document number: 4454/DELNP/2006

Country of ref document: IN

NENP Non-entry into the national phase

Ref country code: DE

WWW Wipo information: withdrawn in national office

Ref document number: DE

WWP Wipo information: published in national office

Ref document number: 2005706396

Country of ref document: EP

WWW Wipo information: withdrawn in national office

Ref document number: 2005706396

Country of ref document: EP