CA2723005A1 - Automated software production system - Google Patents
Automated software production system Download PDFInfo
- Publication number
- CA2723005A1 CA2723005A1 CA2723005A CA2723005A CA2723005A1 CA 2723005 A1 CA2723005 A1 CA 2723005A1 CA 2723005 A CA2723005 A CA 2723005A CA 2723005 A CA2723005 A CA 2723005A CA 2723005 A1 CA2723005 A1 CA 2723005A1
- Authority
- CA
- Canada
- Prior art keywords
- class
- service
- generate
- source code
- components
- Prior art date
- Legal status (The legal status 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 status listed.)
- Abandoned
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
- G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
- G06F16/20—Information retrieval; Database structures therefor; File system structures therefor of structured data, e.g. relational data
- G06F16/23—Updating
- G06F16/2365—Ensuring data consistency and integrity
-
- 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
- G06F8/35—Creation or generation of source code model driven
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/70—Software maintenance or management
- G06F8/73—Program documentation
Abstract
An automated software production system is provided, in which system requirements are captured, converted into a formal specification, and validated for correctness and completeness. In addition, a translator is provided to automatically generate a complete, robust software application based on the validated formal specification, including user-interface code and error handling code.
Description
AUTOMATIC SOFTWARE PRODUCTION SYSTEM
FIELD OF THE INVENTION
The present invention relates to computer systems and more particularly to an automatic software production system and methodology suitable for stand-alone systems and on the Internet.
BACKGROUND OF THE INVENTION
. Software engineering is the application of a systematic and disciplined approach to the development and maintenance of computer programs, applications, and other software systems. Due to the increasing computerization of the world's economy, the need for effective software engineering methodologies is more important than ever.
The traditional software development process involves a number of phases.
First, the requirements of the program are specified, typically in the form of a written specification document based on customer needs. Then, a software developer writes source code to implement the requirements, for example, by designing data structures and coding the system logic. Finally, the software developer undergoes an extensive testing and debugging phase in which mistakes and ambiguities in the requirements are identified and errors in the software code are fixed. Having to refine the system requirements is one of the most serious problems that might occur, because any modification to the requirements necessitates a redevelopment of the source code, starting the process all over again. Thus, the testing and debugging phase is the longest phase in the software engineering process and the most difficult to estimate completion times.
For the past forty years, there have been many attempts to improve isolated portions of the software engineering process. For example, the creation of first higher-level `r.
languages such as FORTRAN and then of structured programming languages such as ALGOL has helped ease the burden of implementing the system logic. As another example, the introduction of object-oriented methodologies has helped in the design and implementation of the data structures. These improvements in the software engineering process have lessened the mismatch between the problem space, which is the Conceptual Model for the application, and the solution space, which is the actual software code.
Nevertheless, some mismatch between the problem space and the solution space remains, which gives rise to an opportunity for programming errors. Because of the programming errors, it is necessary to undergo an extensive testing and debugging phase to isolate and fix the software faults.
Lately, there has been some interest in the use of "requirements analysis" and Computer Aided Software Engineering (CASE) to facilitate the first phase of the software engineering process, which is the identification and specification of the requirements. In particular, these approaches attempt to allow for software engineers to formally specify the requirements and build a prototype to validate and test the requirements. After the requirements are tested, the prototype is discarded and the software engineer develops the complete software application based on the requirements.
One example is known as "OMTROLL", whose objective is to assist software designers by means of an Object Modeling Technique (OMT)-compliant graphical notation to build the formal specification of the system. This specification is based on the TROLL specification language and has to be refined to a complete system specification.
In addition, OMTROLL has a CASE support called TrollWorkbench, which provides a prototyping function by generating an independently executable prototype from a graphical conceptual specification. The prototype generated is a C-H- program that includes the static/dynamic aspects of the system and uses an Ingress database as a repository of the specification.
OBLOG is another object-oriented approach for software development that falls TM
within the scope of the European ESPRIT project IS-CORE (Information Systems-Correctness and Reusability). The OBLOG semantics is formalized in the context of the
FIELD OF THE INVENTION
The present invention relates to computer systems and more particularly to an automatic software production system and methodology suitable for stand-alone systems and on the Internet.
BACKGROUND OF THE INVENTION
. Software engineering is the application of a systematic and disciplined approach to the development and maintenance of computer programs, applications, and other software systems. Due to the increasing computerization of the world's economy, the need for effective software engineering methodologies is more important than ever.
The traditional software development process involves a number of phases.
First, the requirements of the program are specified, typically in the form of a written specification document based on customer needs. Then, a software developer writes source code to implement the requirements, for example, by designing data structures and coding the system logic. Finally, the software developer undergoes an extensive testing and debugging phase in which mistakes and ambiguities in the requirements are identified and errors in the software code are fixed. Having to refine the system requirements is one of the most serious problems that might occur, because any modification to the requirements necessitates a redevelopment of the source code, starting the process all over again. Thus, the testing and debugging phase is the longest phase in the software engineering process and the most difficult to estimate completion times.
For the past forty years, there have been many attempts to improve isolated portions of the software engineering process. For example, the creation of first higher-level `r.
languages such as FORTRAN and then of structured programming languages such as ALGOL has helped ease the burden of implementing the system logic. As another example, the introduction of object-oriented methodologies has helped in the design and implementation of the data structures. These improvements in the software engineering process have lessened the mismatch between the problem space, which is the Conceptual Model for the application, and the solution space, which is the actual software code.
Nevertheless, some mismatch between the problem space and the solution space remains, which gives rise to an opportunity for programming errors. Because of the programming errors, it is necessary to undergo an extensive testing and debugging phase to isolate and fix the software faults.
Lately, there has been some interest in the use of "requirements analysis" and Computer Aided Software Engineering (CASE) to facilitate the first phase of the software engineering process, which is the identification and specification of the requirements. In particular, these approaches attempt to allow for software engineers to formally specify the requirements and build a prototype to validate and test the requirements. After the requirements are tested, the prototype is discarded and the software engineer develops the complete software application based on the requirements.
One example is known as "OMTROLL", whose objective is to assist software designers by means of an Object Modeling Technique (OMT)-compliant graphical notation to build the formal specification of the system. This specification is based on the TROLL specification language and has to be refined to a complete system specification.
In addition, OMTROLL has a CASE support called TrollWorkbench, which provides a prototyping function by generating an independently executable prototype from a graphical conceptual specification. The prototype generated is a C-H- program that includes the static/dynamic aspects of the system and uses an Ingress database as a repository of the specification.
OBLOG is another object-oriented approach for software development that falls TM
within the scope of the European ESPRIT project IS-CORE (Information Systems-Correctness and Reusability). The OBLOG semantics is formalized in the context of the
2 theory of categories. OBLOG also employs a CASE tool for introducing the specifications, and enables a developer to build a prototype by supplying rewrite rules to convert the specifications into code for the prototype. The rewrite rules must be written using a specific language provided by OBLOG.
Another approach that focuses more on levels of formalism is the Object System TM TM
Analysis model (OSA). The aim of OSA is to develop a method that enables system designers to work with different levels of formalism, ranging from informal to mathematically rigorous. In this context, this kind of tunable formalism encourages both theoreticians and practitioners to work with the same model allowing them to explore the difficulties encountered in making model and languages equivalent and resolve these rM TM
difficulties in the context of OSA for a particular language. OSA also has a CASE
!TM TM
support tool called IPOST, which can generate a prototype from an OSA model to validate the requirements.
A different approach has been proposed by SOFL (Structured-Object-based-Formal Language), whose aim is to address the integration of formal methods into established industrial software processes using an integration of formal methods, structured analysis and specifications, and an object-based method. SOFL
facilitates the transformation from requirements specifications in a structured style to a design in an object-based style and facilitates the transformation from designs to programs in the appropriate style. In accordance with the previous arguments, the SOFL
proposal attempts to overcome the fact that formal methods have not been largely used in industry, by finding mechanisms to link object-oriented methodology and structured techniques TM
with formal methods, e.g. VDM (Vienna Development Method) style semantics for its specification modules. Combining structured and objected-oriented techniques in a single method, however, makes it difficult to clarify the method semantics;
thus, effective tool support is necessary for checking consistency.
Another approach that focuses more on levels of formalism is the Object System TM TM
Analysis model (OSA). The aim of OSA is to develop a method that enables system designers to work with different levels of formalism, ranging from informal to mathematically rigorous. In this context, this kind of tunable formalism encourages both theoreticians and practitioners to work with the same model allowing them to explore the difficulties encountered in making model and languages equivalent and resolve these rM TM
difficulties in the context of OSA for a particular language. OSA also has a CASE
!TM TM
support tool called IPOST, which can generate a prototype from an OSA model to validate the requirements.
A different approach has been proposed by SOFL (Structured-Object-based-Formal Language), whose aim is to address the integration of formal methods into established industrial software processes using an integration of formal methods, structured analysis and specifications, and an object-based method. SOFL
facilitates the transformation from requirements specifications in a structured style to a design in an object-based style and facilitates the transformation from designs to programs in the appropriate style. In accordance with the previous arguments, the SOFL
proposal attempts to overcome the fact that formal methods have not been largely used in industry, by finding mechanisms to link object-oriented methodology and structured techniques TM
with formal methods, e.g. VDM (Vienna Development Method) style semantics for its specification modules. Combining structured and objected-oriented techniques in a single method, however, makes it difficult to clarify the method semantics;
thus, effective tool support is necessary for checking consistency.
3 Still another approach is known as TRADE (Toolkit for Requirements and Design Engineering), whose conceptual framework distinguishes external system interactions from internal components. TRADE contains techniques from structured and object-TM' oriented specification and design methods. A graphical editor called TCM
(Toolkit for Conceptual Modeling) is provided to support the TRADE framework.
Although these approaches are of some help for the first phase, i.e. in refining the requirements before the computer application is coded, they do not address the main source for the lack of productivity during later phases of the software engineering process, namely the programming and testing/debugging phases. For example, once the IO requirements are identified, the software engineer typically discards the prototype generated by most of these approaches and then designs and implements the requirements in a standard programming language such as C++. The newly developed code, due to the mismatch between the problem space and the solution space, will commonly contain coding errors and will need to be extensively tested and debugged.
Even if the prototype is not discarded and used as skeleton for the final application, the software developer must still develop additional code, especially to implement the user interface and error processing. In this case, there still remains the need for testing and debugging the code the programmer has written. The rule-rewriting approach of OBLOG, moreover, fails to address this need, because the difficulties associated with programming are merely shifted one level back, to the development of the rewriting rules in an unfamiliar, proprietary language.
TM
Other approaches include those of Rational and Sterling, but these are not based on a formal language.
Therefore, there exists a long-felt need for improving the software engineering process, especially for reducing the amount of time spent in the programming and testing phases. In addition, a need exists for a way to reducing programming errors during the course of developing a robust software application. Furthermore, there is also a need for
(Toolkit for Conceptual Modeling) is provided to support the TRADE framework.
Although these approaches are of some help for the first phase, i.e. in refining the requirements before the computer application is coded, they do not address the main source for the lack of productivity during later phases of the software engineering process, namely the programming and testing/debugging phases. For example, once the IO requirements are identified, the software engineer typically discards the prototype generated by most of these approaches and then designs and implements the requirements in a standard programming language such as C++. The newly developed code, due to the mismatch between the problem space and the solution space, will commonly contain coding errors and will need to be extensively tested and debugged.
Even if the prototype is not discarded and used as skeleton for the final application, the software developer must still develop additional code, especially to implement the user interface and error processing. In this case, there still remains the need for testing and debugging the code the programmer has written. The rule-rewriting approach of OBLOG, moreover, fails to address this need, because the difficulties associated with programming are merely shifted one level back, to the development of the rewriting rules in an unfamiliar, proprietary language.
TM
Other approaches include those of Rational and Sterling, but these are not based on a formal language.
Therefore, there exists a long-felt need for improving the software engineering process, especially for reducing the amount of time spent in the programming and testing phases. In addition, a need exists for a way to reducing programming errors during the course of developing a robust software application. Furthermore, there is also a need for
4 facilitating the maintenance of software applications when their requirements have changed.
SUMMARY OF THE INVENTION
These and other needs are addressed by the present invention, in which system requirements are captured (e.g. through a graphical user interface), converted into a formal specification, and validated for correctness and completeness. In addition, a translator is provided to automatically generate a complete, robust software application based on the validated formal specification. By generating the application code from the validated formal specification, error-free source code strategies can be employed, freeing the developer from having to manually produce the source code or extend an incomplete prototype. Therefore, the error-prone, manual programming phase of the traditional software engineering process is eliminated, and the testing and debugging time is greatly reduced. In one example, the software development time of an application was reduced to 27% of the original time. Software maintenance is also reduced, because the traditional coding, testing, and revalidation cycles is eliminated.
One aspect of the present invention springs from the insight that ambiguity is a major source of programming errors associated with conventional object-oriented and higher-order programming languages such as C++. Accordingly, an automated software production tool, software, and methodology are provided, in which a graphical user interface is presented to allow a user to input unambiguous formal requirements for the software application. Based on the formal requirements input for the software application, a formal specification for the software application is produced and validated, from which the software application is generated. By generating the software application directly from an unambiguous, validated formal specification, the software developer can avoid the programming errors associated with conventional programming languages, and instead work directly in the problem space. In one embodiment, error-handling
SUMMARY OF THE INVENTION
These and other needs are addressed by the present invention, in which system requirements are captured (e.g. through a graphical user interface), converted into a formal specification, and validated for correctness and completeness. In addition, a translator is provided to automatically generate a complete, robust software application based on the validated formal specification. By generating the application code from the validated formal specification, error-free source code strategies can be employed, freeing the developer from having to manually produce the source code or extend an incomplete prototype. Therefore, the error-prone, manual programming phase of the traditional software engineering process is eliminated, and the testing and debugging time is greatly reduced. In one example, the software development time of an application was reduced to 27% of the original time. Software maintenance is also reduced, because the traditional coding, testing, and revalidation cycles is eliminated.
One aspect of the present invention springs from the insight that ambiguity is a major source of programming errors associated with conventional object-oriented and higher-order programming languages such as C++. Accordingly, an automated software production tool, software, and methodology are provided, in which a graphical user interface is presented to allow a user to input unambiguous formal requirements for the software application. Based on the formal requirements input for the software application, a formal specification for the software application is produced and validated, from which the software application is generated. By generating the software application directly from an unambiguous, validated formal specification, the software developer can avoid the programming errors associated with conventional programming languages, and instead work directly in the problem space. In one embodiment, error-handling
5 instructions are also produced when the software application is generated so as to create a robust, final software application.
Another aspect of the present invention stems from the realization that a major source of inadequacy of conventional prototyping techniques is that these techniques lack the capability to specify the user interface aspects. Thus, such conventional prototypes have primitive user interfaces that are unacceptable for final, customer-ready software application. Accordingly, this aspect of the invention relates to an automated software production tool, software, and methodology that include a formal specification of a Conceptual Model that specifies requirements for a software application. The Conceptual Model includes a Presentation Model that specifies patterns for a user interface of the software application. The formal specification, which also specifies the Presentation Model, is validated; and the software application is then generated based on the validated formal specification. As a result, the generated software application includes instructions for handling the user interface in accordance with the patterns specified in the Presentation Model. In fact, the code generated for the software application is very well suited for deployment on the Internet because the code supports high-volume, transactional, scalable, and reliable system logic functions, and the Presentation Model enables creative designers not to be concerned about details of coding the user interface.
Still other objects and advantages of the present invention will become readily apparent from the following detailed description, simply by way of illustration of the best mode contemplated of carrying out the invention. As will be realized, the invention is capable of other and different embodiments, and its several details are capable of modifications in various obvious respects, all without departing from the invention.
Accordingly, the drawing and description are to be regarded as illustrative in nature, and not as restrictive. ki
Another aspect of the present invention stems from the realization that a major source of inadequacy of conventional prototyping techniques is that these techniques lack the capability to specify the user interface aspects. Thus, such conventional prototypes have primitive user interfaces that are unacceptable for final, customer-ready software application. Accordingly, this aspect of the invention relates to an automated software production tool, software, and methodology that include a formal specification of a Conceptual Model that specifies requirements for a software application. The Conceptual Model includes a Presentation Model that specifies patterns for a user interface of the software application. The formal specification, which also specifies the Presentation Model, is validated; and the software application is then generated based on the validated formal specification. As a result, the generated software application includes instructions for handling the user interface in accordance with the patterns specified in the Presentation Model. In fact, the code generated for the software application is very well suited for deployment on the Internet because the code supports high-volume, transactional, scalable, and reliable system logic functions, and the Presentation Model enables creative designers not to be concerned about details of coding the user interface.
Still other objects and advantages of the present invention will become readily apparent from the following detailed description, simply by way of illustration of the best mode contemplated of carrying out the invention. As will be realized, the invention is capable of other and different embodiments, and its several details are capable of modifications in various obvious respects, all without departing from the invention.
Accordingly, the drawing and description are to be regarded as illustrative in nature, and not as restrictive. ki
6 BRIEF DESCRIPTION OF THE DRAWINGS
The present invention is illustrated by way of example, and not by way of limitation, in the figures of the accompanying drawings and in which like reference numerals refer to similar elements and in which:
FIG. 1 depicts a computer system that can be used to implement an embodiment of the present invention.
FIG. 2 is a schematic block diagram illustrating the high-level architecture and data flows of an automatic software production system in accordance with one embodiment of the present invention.
FIG. 3 illustrates an example of an object model for a library system with readers, books, and loans.
FIG. 4A illustrates an exemplary state transition diagram in accordance with one embodiment of the present invention.
FIG. 4B illustrates an exemplary object interaction diagram in accordance with one embodiment of the present invention.
FIG. 5 illustrates an exemplary dialog for receiving input for the functional model.
FIG. 6 is a flow diagram illustrating the high level view of the operation of translating a formal specification into a full application by following what it is referred to as an "Execution Model"."
DESCRIPTION OF THE PREFERRED EMBODIMENT
An automatic software production system is described. In the following description, for the purposes of explanation, numerous specific details are set forth in order to provide a thorough understanding of the present invention. It will be apparent, however, to one skilled in the art that the present invention may be practiced without these specific details. In other instances, well-known structures and devices are shown in block diagram form in order to avoid unnecessarily obscuring the present invention.
The present invention is illustrated by way of example, and not by way of limitation, in the figures of the accompanying drawings and in which like reference numerals refer to similar elements and in which:
FIG. 1 depicts a computer system that can be used to implement an embodiment of the present invention.
FIG. 2 is a schematic block diagram illustrating the high-level architecture and data flows of an automatic software production system in accordance with one embodiment of the present invention.
FIG. 3 illustrates an example of an object model for a library system with readers, books, and loans.
FIG. 4A illustrates an exemplary state transition diagram in accordance with one embodiment of the present invention.
FIG. 4B illustrates an exemplary object interaction diagram in accordance with one embodiment of the present invention.
FIG. 5 illustrates an exemplary dialog for receiving input for the functional model.
FIG. 6 is a flow diagram illustrating the high level view of the operation of translating a formal specification into a full application by following what it is referred to as an "Execution Model"."
DESCRIPTION OF THE PREFERRED EMBODIMENT
An automatic software production system is described. In the following description, for the purposes of explanation, numerous specific details are set forth in order to provide a thorough understanding of the present invention. It will be apparent, however, to one skilled in the art that the present invention may be practiced without these specific details. In other instances, well-known structures and devices are shown in block diagram form in order to avoid unnecessarily obscuring the present invention.
7 HARDWARE OVERVIEW
FIG. 1 is a block diagram that illustrates a computer system 100 upon which an embodiment of the invention may be implemented. Computer system 100 includes a bus 102 or other communication mechanism for communicating information, and a processor 104 coupled with bus 102 for processing information. Computer system 100 also includes a main memory 106, such as a random access memory (RAM) or other dynamic storage device, coupled to bus 102 for storing information and instructions to be executed by processor 104. Main memory 106 also may be used for storing temporary variables or other intermediate information during execution of instructions to be executed by processor 104. Computer system 100 further includes a read only memory (ROM) 108 or other static storage device coupled to bus 102 for storing static information and instructions for processor 104. A storage device 110, such as a magnetic disk or optical disk, is provided and coupled to bus 102 for storing information and instructions.
Computer system 100 may be coupled via bus 102 to a display 112, such as a cathode ray tube (CRT), for displaying information to a computer user. An input device 114, including alphanumeric and other keys, is coupled to bus 102 for communicating information and command selections to processor 104. Another type of user input device is cursor control 116, such as a mouse, a trackball, or cursor direction keys for communicating direction information and command selections to processor 104 and for controlling cursor movement on display 112. This input device typically has two degrees of freedom in two axes, a first axis (e.g., x) and a second axis (e.g., y), that allows the device to specify positions in a plane.
The invention is related to the use of computer system 100 for automatic software production. According to one embodiment of the invention, automatic software production is provided by computer system 100 in response to processor 104 executing one or more sequences of one or more instructions contained in main memory 106. Such
FIG. 1 is a block diagram that illustrates a computer system 100 upon which an embodiment of the invention may be implemented. Computer system 100 includes a bus 102 or other communication mechanism for communicating information, and a processor 104 coupled with bus 102 for processing information. Computer system 100 also includes a main memory 106, such as a random access memory (RAM) or other dynamic storage device, coupled to bus 102 for storing information and instructions to be executed by processor 104. Main memory 106 also may be used for storing temporary variables or other intermediate information during execution of instructions to be executed by processor 104. Computer system 100 further includes a read only memory (ROM) 108 or other static storage device coupled to bus 102 for storing static information and instructions for processor 104. A storage device 110, such as a magnetic disk or optical disk, is provided and coupled to bus 102 for storing information and instructions.
Computer system 100 may be coupled via bus 102 to a display 112, such as a cathode ray tube (CRT), for displaying information to a computer user. An input device 114, including alphanumeric and other keys, is coupled to bus 102 for communicating information and command selections to processor 104. Another type of user input device is cursor control 116, such as a mouse, a trackball, or cursor direction keys for communicating direction information and command selections to processor 104 and for controlling cursor movement on display 112. This input device typically has two degrees of freedom in two axes, a first axis (e.g., x) and a second axis (e.g., y), that allows the device to specify positions in a plane.
The invention is related to the use of computer system 100 for automatic software production. According to one embodiment of the invention, automatic software production is provided by computer system 100 in response to processor 104 executing one or more sequences of one or more instructions contained in main memory 106. Such
8 instructions may be read into main memory 106 from another computer-readable medium, such as storage device 110. Execution of the sequences of instructions contained in main memory 106 causes processor 104 to perform the process steps described herein. One or more processors in a multi-processing arrangement may also be employed to execute the sequences of instructions contained in main memory 106. In alternative embodiments, hard-wired circuitry may be used in place of or in combination with software instructions to implement the invention. Thus, embodiments of the invention are not limited to any specific combination of hardware circuitry and software.
The term "computer-readable medium" as used herein refers to any medium that participates in providing instructions to processor 104 for execution. Such a medium may take many forms, including but not limited to, non-volatile media, volatile media, and transmission media. Non-volatile media include, for example, optical or magnetic disks, such as storage device 110. Volatile media include dynamic memory, such as main memory 106. Transmission media include coaxial cables, copper wire and fiber optics, including the wires that comprise bus 102. Transmission media can also take the form of acoustic or light waves, such as those generated during radio frequency (RF) and infrared (IR) data communications. Common forms of computer-readable media include, for example, a floppy disk, a flexible disk, hard disk, magnetic tape, any other magnetic medium, a CD-ROM, DVD, any other optical medium, punch cards, paper tape, any other physical medium with patterns of holes, a RAM, a PROM, and EPROM, a FLASH-EPROM, EPROM, any other memory chip or cartridge, a carrier wave as described hereinafter, or any other medium from which a computer can read.
Various forms of computer readable media may be involved in carrying one or more sequences of one or more instructions to processor 104 for execution. For example, the instructions may initially be borne on a magnetic disk of a remote computer. The remote computer can load the instructions into its dynamic memory and send the instructions over a telephone line using a modem. A modem local to computer system
The term "computer-readable medium" as used herein refers to any medium that participates in providing instructions to processor 104 for execution. Such a medium may take many forms, including but not limited to, non-volatile media, volatile media, and transmission media. Non-volatile media include, for example, optical or magnetic disks, such as storage device 110. Volatile media include dynamic memory, such as main memory 106. Transmission media include coaxial cables, copper wire and fiber optics, including the wires that comprise bus 102. Transmission media can also take the form of acoustic or light waves, such as those generated during radio frequency (RF) and infrared (IR) data communications. Common forms of computer-readable media include, for example, a floppy disk, a flexible disk, hard disk, magnetic tape, any other magnetic medium, a CD-ROM, DVD, any other optical medium, punch cards, paper tape, any other physical medium with patterns of holes, a RAM, a PROM, and EPROM, a FLASH-EPROM, EPROM, any other memory chip or cartridge, a carrier wave as described hereinafter, or any other medium from which a computer can read.
Various forms of computer readable media may be involved in carrying one or more sequences of one or more instructions to processor 104 for execution. For example, the instructions may initially be borne on a magnetic disk of a remote computer. The remote computer can load the instructions into its dynamic memory and send the instructions over a telephone line using a modem. A modem local to computer system
9 100 can receive the data on the telephone line and use an infrared transmitter to convert the data to an infrared signal. An infrared detector coupled to bus 102 can receive the data carried in the infrared signal and place the data on bus 102. Bus 102 carries the data to main memory 106, from which processor 104 retrieves and executes the instructions.
The instructions received by main memory 106 may optionally be stored on storage device 110 either before or after execution by processor 104.
Computer system 100 also includes a communication interface 118 coupled to bus 102. Communication interface 118 provides a two-way data communication coupling to a network link 120 that is connected to a local network 122. For example, communication interface 118 may be an integrated services digital network (ISDN) card or a modem to provide a data communication connection to a corresponding type of telephone line. As another example, communication interface 118 may be a local area network (LAN) card to provide a data communication connection to a compatible LAN.
Wireless links may also be implemented. In any such implementation, communication interface 118 sends and receives electrical, electromagnetic or optical signals that carry digital data streams representing various types of information.
Network link 120 typically provides data communication through one or more networks to other data devices. For example, network link 120 may provide a connection through local network 122 to a host computer 124 or to data equipment operated by an Internet Service Provider (ISP) 126. ISP 126 in turn provides data communication services through the worldwide packet data communication network, now commonly referred to as the "Internet" 128. Local network 122 and Internet 128 both use electrical, electromagnetic or optical signals that carry digital data streams. The signals through the various networks and the signals on network link 120 and through communication interface 118, which carry the digital data to and from computer system 100, are exemplary forms of carrier waves transporting the information.
Computer system 100 can send messages and receive data, including program code, through the network(s), network link 120, and communication interface 118. In the Internet example, a server 130 might transmit a requested code for an application program through Internet 128, ISP 126, local network 122 and communication interface 118. In accordance with the invention, one such downloaded application provides for automatic software production as described herein. The received code may be executed by processor 104 as it is received, and/or stored in storage device 110, or other non-volatile storage for later execution. In this manner, computer system 100 may obtain application code in the form of a carrier wave.
CONCEPTUAL OVERVIEW
FIG. 2 is a schematic block diagram illustrating the high-level architecture and data flows of an automatic software production system 202 in accordance with one embodiment of the present invention. The automatic software production system 202 is configured to accept requirements 200 as input, and produce a complete, robust application 204 (including both system logic and user-interface code), a database schema 206, and documentation 208. In one implementation, the automatic software production system 202 includes a Computer Aided Software Engineering (CASE) tool 210 front end to allow a user to input the requirements, a validator 220 for validating the input requirements 200, and several translators to convert the validated input requirements 200 into a complete, robust application 204. These translators may include a system logic translator 232, a user-interface translator 234, a database generator 236, and a documentation generator 238.
During operation of one embodiment, requirements 200 specifying a Conceptual Model for the application are gathered using diagrams and textual interactive dialogs presented by the CASE tool 210. Preferably, the CASE tool 210 employs object-oriented modeling techniques to avoid the complexity typically associated with the use of purely textual formal methods. In one implementation, the Conceptual Model is subdivided into four complementary models: an object model, a dynamic model, a functional model, and a Presentation Model. These models are described in greater detail hereinafter. After gathering the requirements 200, the CASE tool 210 stores the input requirements as a formal specification 215 in accordance with a formal specification language, for example, the OASIS language, which is an object-oriented language for information systems developed at the Valencia University of Technology in Spain.Using extended grammar defined by the formal language, the validator 220 syntactically and semantically validates the formal specification 215 to be correct and complete.. If the formal specification 215 does not pass validation, no application is allowed to be generated; therefore, only correct and complete applications are allowed be generated.
If, on the other hand, the formal specification 215 does indeed pass validation, automatic software production processes, some of wich are referred to as "
translators"
(system logic and user interface ones), are employed to implement a precise execution model that corresponds to the validated formal specification 215.. In particular, translators 232 and 234 produce application source code 204 in a high-order language such as C++, Visual Basic or JAVA for the application's system-logic and user-interface, respectively. In one implementation, a database generator 236 also produces instructions in, for example, a Structure Query Language (SQL) scripting language to create the data model for the application in an industry-standard ANSI-92 SQL Relational Database Management System (RDBMS).
In addition, one implementation also employs a document generator 238 to automatically generate serviceable system documentation from the information introduced in the Conceptual Model.
CASE MODELER
As mentioned herein above, the CASE tool 210 preferably employs object-oriented modeling techniques to avoid the complexity typically associated with the use of purely textual formal methods. Rather, four complementary models, that of the object model, the dynamic model, the functional model and the Presentation Model, are employed to allow a designer to specify the system requirements. In contrast with conventional techniques, however, the CASE tool 210 actually captures a formal specification of the designer's system "on the fly" according to a formal specification language, while the designer is specifying the system with the CASE tool 210..
This feature enables the introduction of well-defined expressions in the specification, which is often lacking in the conventional methodologies. In particular, the CASE tool 210 enforces the restriction that only the information relevant for filling a class definition in the formal specification language can be introduced. The use of a formal specification, input by means of the CASE tool 210, therefore provides the environment to validate and verify the system in the solution space, thereby obtaining a software product that is functionally equivalent to the specification as explained hereinafter. Nevertheless this is always done preserving this external view, which is compliant with the most extended modeling techniques, as stated before. In this way, the and formalism characteristic of many conventional approaches is hidden from the designer, who is made to feel comfortable using a graphical modeling notation.
With respect to the notation, conceptual modeling in one embodiment employs diagrams that are compliant with the Unified Modeling Language (UML); thus, system designers need not learn another graphical notation in order to model an information system. In accordance with a widely accepted object oriented conceptual modeling principles, the Conceptual Model is subdivided into an object model, a dynamic model, and a functional model. These three models, however, are insufficient by themselves to specify a complete application, because a complete application also requires a user interface. Therefore, the CASE tool 210 also collects information about user-interface patterns, in a fourth model referred to as "Presentation Model", which will be translated into the code for the application. In one embodiment, the CASE tool 210 collects information organized around projects that correspond to different applications. Each project built by the CASE tool 210 can include information about classes, relationships between classes, global transactions, global functions, and views.
Each class contains attributes, services, derivations, constraints, transaction formulas, triggers, display sets, filters, population selection patterns, a state transition diagram and formal interfaces.. In addition to the information in these lists, a class can also store a name, alias and a default population selection interface pattern.
Extra information is stored as remarks that the designer can input information about why a class does exist in a model.
Each attribute can have the following characteristics: name, formal data type (e.g. fl constant, variable, derived), data type (real, string...), default value, whether the attribute is an identifier for distinguishing the objects of the class, length, whether the attribute is required when the object is created, whether the attribute can be assigned a NULL value, and a field to introduce some remarks about why the attribute has been created. Each attribute can also include information about valuations, which are formulas that declare how the object's state is changed by means of events. Valuation formulas are structured in the following parts: a condition (that must be satisfied to apply the effect), an event and an effect of the event to the particular attribute. An attribute may also include user interface patterns belonging to the Presentation Model to be applied in the corresponding services arguments related to the attribute. {
Services can be of two types: events and transactions. Events are atomic operations, while transactions are composed of services which can be in turn events or transactions. Every service can have the following characteristics: name, type of service (event or transaction), service alias, remarks and a help message. Events can be of three types: new, destroy, or none of them. Events can also be shared by several classes of the project. Shared events belong to all classes sharing them. Transactions have a formula that expresses the composition of services. In addition to this information, services store a list of arguments whose characteristics are: name, data type, whether nulls are allowed as a valid value, whether the argument represents a set of objects (collection), default value, alias and remarks. Additionally, for each argument, user-interface patterns related to arguments are: introduction pattern, population selection pattern, defined selection pattern and dependency pattern. The class can also store information about derivations, and constraints. Each derivation specifies a list of pairs condition-formula, specifying which formula will be applied under every condition. Each constraint is a well formed formula plus the error message that will be displayed when the constraint was violated.
For the dynamic constraints, the formula will be internally translated into a graph which constitutes the guide for its evaluation.
A class can also store triggers. Each trigger may be composed of trigger target specified in terms of self, class or object, trigger condition, triggered action (service plus a list of possible agents) to be activated and a list of default values associated with the arguments of the related service. A class can also have display sets, filters and population selection patterns as user-interface patterns of the Presentation Model affecting the class.
Each display set can store elements of visualization (attributes to be displayed to the user). Each filter is composed of a well formed formula and a list of auxiliary variables that are useful to define the formula. The population selection pattern is related to a display set and a filter. Classes also have a State Transition Diagram that is a set of states and transitions between them. Each state transition is related to an action (service plus list of possible agents) that can change the state of the object. Actions may have preconditions and the corresponding error message (to be displayed if the precondition does not hold). Preconditions are formulas that need to be satisfied in order to execute the corresponding action. In case of non-deterministic transitions, determinism is achieved by means of labelling each transition with a control condition. A control condition is a formula that specifies which state transition will take effect. Finally, a class can store a list of interfaces. Each interface stores the list of services that an actor can execute (agents) and the list of attributes that can be observed.
The model also maintains information on relationships between classes, which can be of two types: aggregation ("has a" or "part of") and inheritance ("is a"). Each aggregation relationship indicates composition of objects and captures the information about cardinalities (numbers of minimum and maximum participants in the aggregation relationship, whether the aggregation is static or dynamic, whether the aggregation is inclusive or referential, whether the aggregation has an identification dependence, and a grouping clause when the aggregation is multi-valued. Each inheritance relationship indicates specialization of objects and stores the name of the parent class, the name of the child class and whether the specialization is temporary or permanent. Finally, if the specialization is permanent it stores a well-formed formula on constant attributes as specialization condition. If the specialization is temporary it stores either condition or the list of events that activate/deactivate the child role.
Finally, the project can also capture a list of global transactions in which the relevant characteristics to be stored include the name of the global interaction, the formula, and the list of arguments. A list of global functions can also be captured, in which each function stores a name, a data type of the returned value, a set of arguments (similar to services), and comments about the function.
A project may have a set of views, wich constitute the particular vision that a set of selected agent classes has of the system. That is, the set of formal interfaces (attributes and services) allowed per agent class. Each agent class has a list of interfaces.
OBJECT MODEL
The object model is a graphical model that allows the system designer to specify the entities employed in the application in an object-oriented manner, in particular, by defining classes for the entities. Thus, the class definitions include, for example, attributes, services and class relationships (aggregation and inheritance).
Additionally, agent relationships are specified to state that services that objects of a class are allowed to activate.
FIG. 3 illustrates an example of an object model 300 for a library system with readers, books, and loans. Classes, in the object model 300, are represented as rectangles with three areas: the class name, the attributes and the services. In the example, the object model 300 includes a loan class 310 with attributes to indicate a load code 312 and a loan date 314 for when the loan was made. The loan class 300 also includes two services (methods) including one for loaning a book 316 and another for returning the book 318.
The object model 300 also includes a book class 320 having attributes that specify the author 322 of the book, a book code 324, and a state 326 (e.g, reserved, in circulation, checked out, etc.) and services such as new book 328 for creating a new book.
Another class is a librarian class 330, whose name 332 is specified by an attribute and whose creation is done by a new librarian service 334.
Each reader belonging to the library is described with the reader class 340, whose attributes include the age 342, the number of books 344 checked out by the reader, and the name 346 of the reader. Readers may be created with a new reader service 348. An unreliable reader class 350 is also part of the object model to indicate for those readers 340 who cannot be trusted (e.g. due to unpaid fees for overdue books). An unreliable reader 350 may be forgiven 352 by a librarian 330.
In an object model 300, inheritance relationships are represented by using arrows to link classes. For example, the unreliable reader class 350 is connected to the reader claim 340 with an arrow; thus, the unreliable reader class 350 is specified to inherit from, or in other terms is a subclass of, the reader claim 340. The arrow linking the subclass and the base class can be leveled with a specialization condition or an event that activates or cancels the child role. In the exemplary object model 300, the arrow between the unreliable reader class 350 and the reader class 340 is labeled with a "reader.punish/forgive" service. Thus, if a reader 340 is punished, that person becomes an unreliable reader 350. Conversely, if an unreliable reader 350 is forgiven 352, that person becomes a normal reader 340.
Aggregation relationships are represented in the object model 300 by using a line with a diamond from a given component. class to its composite class with the diamond on the composite side. The aggregation determines how many components can be attached to a given container and how many containers a component class can be associated with. In the example, a book 320 and a reader 340 are aggregated in a loan 310, because a loan 310 involves lending a book 320 to a reader 340 of the library. The representation of aggregation also includes its cardinalities in both directions (i.e.
minimum and maximum numbers), role names, and relationship name. In the example, the cardinality of the loan:book relationship from loan to book is 1:1 because exactly one book is the subject of exactly one loan in this Conceptual Model, and from book to loan is 0:1 because a book may or may not be lent at any moment."
Furthermore, agent relationships are represented by dotted lines that connect the associated client class and services of the server class. In the example, a librarian 330 is an agent of a forgive service 352 of the unreliable reader class 350; thus, there is a dotted line between the forgive service 352 and the librarian class 330. This means that a librarian can forgive unreliable readers. As another example, readers 340 are agents of the loan book 316 and return book 318 services.
Finally, shared events are represented by solid lines that connect the associated events between two classes. In the example, the loan book event is a shared event due to the solid line connecting said events in the book class 320 and the reader class 340. A
shared event affects more than object, in which each object may change its state in accordance with its local specification. In the example, the loan book event causes the state of the book 320 to be changed to "not available", the number of books of the reader 340 to be incremented, and create an instance of the loan class 310, aggregations of the book 320 and the reader 340. Since the loan book event creates an instance of loan class 310, it is a "new" event for that aggregated class.
Additional information in the object model is specified to complete the formal description of the class. Specifically, for every class in the object model, the following information is captured as shown in TABLE 1.
Attributes All the aforementioned properties and/or characteristics Services All the aforementioned properties and/or characteristics Derivations Derivation expressions for the derived attributes (those whose value is dependent on other attributes) Constraints Well-formed formulas stating conditions that objects of a class must satisfy Complex specific information associated with aggregation and inheritance Relationships hierarchies Agents Services that can be activated by this class Additional information associated with aggregation and inheritance is also collected. For aggregated classes, the additional information can specify if the aggregation is an association or a composition in accordance with the UML
characterization, or if the aggregation is static or dynamic. For inheritance hierarchies, the additional information can specify if a specialization produced by the inheritance is permanent or temporal. If the specialization is permanent, then the corresponding conditions on the constant attributes must characterize the specialization relationship. On the other hand, if the specialization is temporary, then the condition based on variable attributes or the events that activate/deactivate the child role must be specified.
Some applications may require a large number of classes to fully specify. In this case, classes may be gathered into clusters. Clusters make it easier for the designer or system analyst to understand the application, one cluster at a time. Thus, clusters help reduce the complexity of the view of the object model.
DYNAMIC MODEL
The system class architecture is specified with the object model. Additional features, however, such as which object life cycles can be considered valid, and which inter-object communication can be established, also have to be input in the system specification. For this purpose, a dynamic model is provided.
The dynamic model specifies the behavior of an object in response to services, triggers and global transactions. In one embodiment, the dynamic model is represented by two diagrams, a state transition diagram and an object interaction diagram.
The state transition diagram (STD) is used to describe correct behavior by establishing valid object life cycles for every class. A valid life refers to an appropriate sequence of states that characterizes the correct behavior of the objects that belong to a specific class. Transitions represent valid changes of state. A transition has an action and, optionally, a control condition or guard. An action is composed of a service plus a subset of its valid agents defined in the Object Model. If all the agents are selected, the transition is labeled with an asterisk (*). Control conditions are well formed formulas defined on object attributes and/or service arguments to avoid the possible non-determinism for a given action. Actions might have one precondition that must be satisfied in order to accept its execution. A circle with an imbedded circle represents the state previous to existence of the object. Transitions that have this state as source must be composed of creation actions. Similarly, a bull's eye represent the state after destruction of the object.
Transitions having this state as destination must be composed of destruction actions.
Intermediate states are represented by circles labeled with an state name.
Accordingly, the state transition diagram shows a graphical representation of the various states of an object and transitions between the states. FIG. 4A illustrates an exemplary state transition diagram 400 in accordance with one embodiment of the present invention. States are depicted in the exemplary state transition diagram 400 by means of a circle labeled with the state name. Referring to FIG. 4A, the "bookO" state 404 is indicated by a circle with the name "bookO." Before an object comes into existence, a blank circle 402 is used to represent this "state" of nonexistence, which is the source of the initial transition 410 labeled by a corresponding creation action. A bull's eye 406 is used to represent the state after which an object has been destroyed, as by a transition 416 occasioned by the [*] :
_book action.
destroy Transitions are represented by solid arrows from a source state to a destination state. The middle of the transition arrow is labeled with a text displaying the action , precondition and guards (if proceeds). In the example, transition 412 is labeled with a loan book action associated with the transition 412 and a precondition `if state =
"available". Thus, the system will only accept the execution of the action if the state attribute of the book is "available." In other words, the Conceptual Model requires that a book can only be loaned if the book is available. "As another-example, transition 414 is labeled with a return_book action associated with the transition 414" and a precondition `if state - "lent"'. In other words, the Conceptual Model requires that a book can only be returned if the book has been lent.
The object interaction diagram specifies inter-object communication. Two basic interactions are defined: triggers, which are object services that are automatically activated when a pre-specified condition is satisfied, and global transactions, which are themselves services involving services of different objects and or other global transactions.. There is one state transition diagram for every class, but only one object interaction diagram for the whole Conceptual Model , where the previous interactions will be graphically specified.
In one embodiment, boxes labeled with an underlined name represent class objects. Trigger specifications follow this syntax: destination::action if trigger-condition.
The first component of the trigger is the destination, i.e., the object(s) to which the triggered service is addressed. The trigger destination can be the same object where the condition is satisfied (i.e. self), a specific object, or an entire class population if broadcasting the service. Finally, the triggered service and its corresponding triggering relationship are declared. Global Transactions are graphically specified by connecting the actions involved in the declared interaction. These actions are represented as solid lines linking the objects (boxes) that provide them.
Accordingly, communication between objects and activity rules are described in the object interaction diagram, which presents graphical boxes, graphical triggers, and graphical interactions. FIG. 4B illustrates an exemplary object interaction diagram 420 in accordance with one embodiment of the present invention.
In the object interaction diagram 420, the graphical interactions are represented by lines for the components of a graphical interaction. Graphical boxes, such as reader box 422, are declared, in this case, as special boxes that can reference objects (particular or generic) such as a reader. Graphical triggers are depicted using solid lines that have a text displaying the service to execute and the triggering condition.
Components of graphical interactions also use solid lines. Each one has a text displaying a number of the ~
interaction, and the action that will be executed. In the example, trigger 424 indicates that the reader punish action is to be invoke when the number of books that a reader is currently borrowing reaches 10.
FUNCTIONAL MODEL
Many conventional systems take a shortcut when providing a functional model, which limits the correctness of a functional specification.. Sometimes, the model used breaks the homogeneity of the object-oriented models, as happened with the initial versions of OMT, which proposed using the structured DFDs as a functional model. The use of DFD techniques in an object modeling context has been criticized for being imprecise, mainly because it offers a perspective of the system (the functional perspective), which differs from the other models (the object perspective).
Other methods leave the free-specification of the system operations in the hands of the designer, which leads to inconsistencies. .
One embodiment of the present invention, however, employs a functional model that is quite different with respect to these conventional approaches. In this functional model, the semantics associated with any change of an object state is captured as a consequence of an event occurrence. To do this, the following information is declaratively specified: how every event changes the object state depending on the arguments of the involved event, and the object's current state. This is called "valuation."
In particular, the functional model employs the concept of the categorization of valuations. Three types of valuations are defined: push-pop, state-independent and discrete-domain based. Each type fixes the pattern of information required to define its functionality.
Push pop valuations are those whose relevant events increase or decrease the value of the attribute by a given quantity, or reset the attribute to a certain value.
State-independent valuations give a new value to the attribute involved independently of the previous attribute's value.
Discrete-domain valuations give a value to the attributes from a limited domain based on the attribute's previous value. The different values of this domain model the valid situations that are possible for the attribute..
To illustrate these features, TABLE 2 shows a functional model for a "book number" attribute 344 of the reader class 340, in a Conceptual Model representing a typical library.
CLASS: Reader ATTRIBUTE: book number CATEGORY: push-pop loan( 1 Increase Returno Decrease These valuations are categorized as a push-pop because their relevant events increase or decrease the value of the book number attribute 344 by a given quantity (1).
In the example, its related event loan() has the increasing effect and return() has the decreasing effect.
This categorization of the valuations is a contribution of one aspect of the present invention that allows a complete formal specification to be generated in an automated way, completely capturing a event's functionality Accordingly, the functional model is responsible for capturing the semantics of every change of state for the attributes of a class. It has no graphical diagram. Textual information is collected through an interactive dialog that fills the corresponding part of the Information Structures explained before. FIG. 5 illustrates an exemplary dialog for receiving input for the functional model.
PRESENTATION MODEL
The Presentation Model is a set of pre-defined concepts that can be used to describe user interface requisites. These concepts arise from distilling and abstracting repetitive scenarios in developing the user interfaces. These abstractions of the repetitive scenarios are called patterns. A set of patterns is called a pattern language.
In this sense, the Presentation Model is a collection of patterns designed to reflect user interfaces requirements. A pattern is a clear description of a recurrent problem with a recurrent solution in a given restricted domain and giving an initial context. The documented patterns abstract the essence of the problem and the essence of the solution and therefore can be applied several times to resolve problems that match with the initial context and domain.The pattern language is composed of a plurality of patterns. The present invention is not limited to any particular list of patterns, but the following is a brief description of some user interface patterns that have been found to be useful:
Service Presentation Pattern, Instance Presentation Pattern, Class Population Presentation Pattern, Master-Detail Presentation Pattern and Action Selection Presentation Pattern.
A Service Presentation Pattern captures how a service will request data to the final user. This patterns controls the filling out of service arguments and contains actions to launch the service or to exit, performing no action. It is based on other lower level patterns that refer to more specific interface tasks such as an introduction pattern, defined selection pattern, population selection pattern, dependency pattern, status recovery pattern, supplementary information pattern, and argument grouping presentation:
The introduction pattern handles with restrictions to input data that must be provided to the system by the final user (i.e., the user who employs the final application). In particular, edit-masks and range-values are introduced, constraining the values that can validly be input in the interface. In this manner, the user-entry errors are reduced. This pattern can be applied to arguments in services or to attributes in classes to improve data input process through validating input arguments.
The defined selection pattern specifies a set of valid values for an argument. When the input data items are static, are a few, and are well known, the designer can declare by enumeration a set containing such valid values. This pattern is similar to those that define an enumerated type and an optional default value. Accordingly, the final user can only select an entry from the pre-specified set, thereby reducing error prone input. For example, one representation of this pattern could be a Combo-Box. This pattern can be applied to arguments in services or to attributes in classes to improve data input process.
The population selection pattern handles the display and selection of objects inform among a multiple objects. Specifically, this pattern contains a filter, a display set, and an order criterion, which respectively determine how objects are filtered (Filter Expression), what data is displayed (Display Set), and how objects are ordered (Order Criteria). This pattern may be thought of as a SQL Select statement with columns, where for the filter expression and order by for the ordering clauses, and can be applied to object-valuated arguments in services whenever it is possible to select an object from a given population of existing objects.
The dependency pattern is a set of Event-Condition-Action (ECA) rules allowing the specification of dependency rules between arguments in services.
When arguments are dependent on others, these constraints use this kind of rules.
The status recovery pattern is an implicitly created pattern that recovers data from object attributes to initialize service arguments. This can be modeled as an implicit set of dependency patterns. For example, to change the data associated of a Customer object, a form to launch the change service appears.
If the user provides the Customer OID (Object Identifier), the interfaces can use this OID to search the object and recover the data associated to the Customer, such as name, telephone, address, etc.
Ili The supplementary information pattern handles the feedback that is provided to final users in order to assure they choose or input the correct OID
(object identified) for an existent object. For example, to select a Customer, an OID must be provided. If the name of the Customer is automatically displayed as answer to an OID input, the user receives a valuable feedback data that assures the user in selecting or correcting the input data. The supplementary information pattern is applicable to object-valuated arguments."
The argument grouping presentation pattern captures how to group the requested service arguments according to the user wishes.
An Instance Presentation Pattern captures how the properties of an object are presented to the final user. In this context, the user will be able to launch services or to navigate to other related objects. The instance presentation pattern is a detailed view of an instance.
A Class Population Presentation Pattern captures how the properties of multiple objects of one class are presented to the final user. In this context, once an object is selected, the final user will be able to launch a service or to navigate to other related objects. The objects can also be filtered.
A Master-Detail Presentation Pattern captures how to present a certain object of a class with other related objects that may complete the full detail of the object. To build this pattern the following patterns are used: instance presentation, class population presentation and, recursively, master-detail presentation. In this manner, multi-detail (multiple details) and multi-level master-detail (multiple levels recursively) can be modeled. For example, one scenario involves an invoice header followed by a set of invoice lines related to the invoice.
An Action Selection Pattern captures how the services are offered to final users following the principle of gradual approach. This pattern allows, for example, generating menus of application using a tree structure. The final tree structure will be obtained from the set of services specified in the classes of the Conceptual Model. The user could launch services or queries (observations) defined in the Conceptual Model.
A Filter Expression is a well-formed formula that evaluates to a Boolean type.
This formula is interpreted as follows: the objects that satisfy the formula pass the filter, the ones that not fulfill the condition do not pass the filter. Consequently, the filter acts like a sift that only allows objects that fulfill the formula to pass. These formulas can contain parameters that are resolved at execution time, providing values for the variables or asking them directly to the final user. A filter pattern may be thought of as an abstraction of a SQL where clause, and is applied in a population selection pattern.
A Display Set is an ordered set of attributes that is shown to reflect the status of an object. A Display Set may be thought of as an abstraction of the columns in a SQL
clause, and is applied in a population selection pattern.
The Order Criteria is an ordered set of tuples that contain: an attribute and an order (ascending / descending). This set of tuples fixes an order criterion over the filtered objects. An order criterion pattern may be thought of as an abstraction of an order by SQL clause, and is applied in a population selection pattern.
FORMAL SPECIFICATION
The CASE tool 210, after presenting a user interface for capturing system requirements 200, converts the system requirements into a formal specification 215. In particular the CASE tool 210 builds upon the previously described models as a starting point and automatically generates a corresponding formal and object-oriented specification 215, which acts as a high-level system. repository. In a preferred embodiment, the formal language being employed is OASIS, version 2.2 by Oscar Pastor Lopez and Isidro Ramos Salavert, published October 1995 by the "Servicio de Publicaciones de la Universidad Politecnica de Valencia" (legal deposit number: V-1285-1995).
Conversion of captured system requirements 200 into a formal specification 215 is a main feature of one aspect of the invention: each piece of information introduced in the conceptual modeling step has a corresponding formal counterpart, which is represented as formal language concept. The graphical modeling environment associated with one embodiment of the invention may be thus viewed as an advanced graphical editor for formal specifications.
Therefore, an introductory presentation of the OASIS specification language is provided herein for a more detailed view of this embodiment of the present invention, TABLE 3 shows a formal specification 215 for the reader class that was automatically obtained from the Conceptual Model:
CONCEPTUAL SCHEMA library domains nat,bool,int,date,string class reader identification by_reader_code: (reader_code);
constant-attributes age : String ;
reader-code : String ;
name : String ;
variable attributes book count : Int private events new_reader O new;
destroy reader O destroy;
punishO;
shared events loan() with book;
return() with book;
constraints static book count < 10;
valuation [loan()) book-count= book-Count + 1;
[return O ] book _count= book-count - 1;
preconditions librarian:destroy_reader () if book-number = 0 triggers Self :: punish() if book count = 10;
process reader = librarian:newreader() readerO;
reader0= librarian:destroy_reader() +
loan () readerl;
readerl= if book count=1 return() readero + (if book count > 1 return() + if book count < 10loant)) readerl;
end class END CONCEPTUAL SCHEMA
The meaning of the different sections that integrate the formal description of the exemplary reader class specification is explained. A class in OASIS is made up of a class name "reader", an identification function for instances (objects) of the class, and a type or template that all the instances share.
The identification function by_reader code, characterizes the naming mechanism used by objects and yields a set of surrogates belonging to a predefined sort or to a sort defined by the user (the so-called domains in OASIS). These domains are imported in the class definition. The most usual are predefined as int, nat, real, bool, char, string and date.
They represent numbers, Boolean values, characters, strings and dates in a particular format. New domains can be introduced in a specification by defining the corresponding abstract data type.
A type is the template that collects all the properties (structure and behavior) which are shared by all the potential objects of the class being considered.
Syntactically, the type can be formalized as a signature, which contains sorts, functions, attributes and events to be used, a set of axioms, which are formulas in a dynamic logic, a process query as a set of equations with variables of a sort process that are solved in a given process algebra. When these variables are instantiated, we have the ground terms that represent possible lives of instances (objects).
A class signature contains a set of sorts with a partial order relation. Among this set of sorts is the sort of interest (the class name) associated with the class being defined.
A class signature also contains a set of functions including those functions included in the definition of the (predefined) sorts and the identification function whose sort is the ADT
(Abstract Data Type) for identities implicitly provided with a class specification. The identification function provides values of a given sort to identify objects in order to assure that any object of a given class has a unique identity. For specification purposes, an identification is introduced mechanism comprising a declaration of one or more key maps used as aliases for identifying objects. The key maps are similar to the candidate key notion of the relational model. From a given key value, these maps return an associated object identity. Key maps will be declared as (tuples of) constant attributes.
A class signature also contains a set of attributes (constant, variable, and derived), see constant-attributes and variable-attributes sections in TABLE 3. These attributes all have the sort of the class as domain, and the given sort associated to the attribute being considered as co-domain.
A set of events is also contained in the class signature (see private events and shared events in TABLE 3), with the sort of the class as the domain, plus any additional sort representing event information, and-with the sort of the class (sort of interest) as the co-domain. This so-called sort of interest can be seen as a sub-sort of a general sort process when objects are viewed as processes.
Each event occurrence is labeled by the agent that is allowed to activate it.
When dealing with this actor notion, if the agent x initiates event a is written x : a and called an action; x could be the environment or any object of a system class. In one embodiment, an event always is associated with an agent. When defining an event, the designer is therefore forced to state which agent will be able to activate it.
Consequently, a set A of actions may be defined and obtained from and attached to the initial set of events.
In this way, the notion of the set of object services can be represented as an interface that allows other objects to access the state. The object services can be events (server view) or actions (client view) depending on whether these services are offered or requested. Actions become services requested by an object, by which the object can consult or modify states of other objects (or its own state).
In OASIS, there are the following kinds of dynamic formulas (set of class axioms):
Evaluations are formulas of the form cp [a] p' whose semantics is given by defining a p function that, from a ground action a returns a function between possible worlds. In other words, being a possible world for an object any valid state, the p function determines which transitions between object states are valid after the execution of an action a. In the example, there are the following evaluations:
[loan()] book-count= book_count+l;
[returnl)] book count- book count-1;
Within this dynamic logic environment, the formula cp is evaluated in s e W, and cp' is evaluated in p(a), with p(a) being the world represented by the object state after the execution in s of the action considered.
Derivations are formulas of the type cp- cp'. They define derived attributes p' in terms of the given derivation condition (stated in (p). Derivations basically differ from the evaluation formulas in that this derived evaluation is done in a unique state.
Integrity constraints are formulas that must be satisfied in every world.
Static and dynamic integrity constraints may be distinguished. Static integrity constraints are those defined for every possible world. They must always hold. On the other hand, dynamic ', integrity constraints are those that relate different worlds. They require the use of a temporal logic, with the corresponding temporal logic operators.
Preconditions are formulas with the template -,y[a]false, where cp is a formula that must hold in the world previous to the execution of action a. Only in the worlds }
where cp holds, is a allowed to occur. If -,cp holds, the occurrence of a gives no state as successor. We have the following precondition in the reader specification:
book number = 0 [librarian:destroy_readerO) false;
or, in a more convenient way for specification purposes, we can write librarian:destroy reader() if book number = 0 Triggers are formulas of the form y[-,ajfalse, where -,a is the action negation.
This formula means that a does not occur, and what does occur is not specified. If cp holds and an action other than a occurs, then there is no successor state.
This forces a to occur or the system remains in a blocked state. For instance, using the appropriate dynamic formula where we include in the triggered service information about the destination (according to the trigger expressiveness presented when the object interaction diagram 420 was introduced), we will declare:
book count = 10 [Self::punish()1 false This trigger may be written in an equivalent but more conventional way for specification purposes as:
Self::punish() if book count = 10;
Thus, triggers are actions activated when the condition stated in q) holds.
The main difference between preconditions and triggers comes from the fact that in triggers there is an obligation to activate an action as soon as the given condition is satisfied. In this way triggers allow us to introduce internal activity in the Object Society that is being modeled.
In any of these dynamic formulas, cp, ap' are well-formed formulas in a first order logic that usually refer to a given system state characterized by the set of values attached to attributes of objects in the state or world considered.
In OASIS, an object is defined as an observable process. The process specification in a class allows us to specify object dynamics and determines the access relationship between the states of instances. Processes are constructed by using events as atomic _ actions. However, the designer also has the choice of grouping events in execution units, which are called transactions.
The molecular units that are the transactions have two main properties. First, they follow an all-or-nothing policy with respect to the execution of the involved events:
when a failure happens during a transaction execution, the resultant state will be the initial one. Second, they exhibit the non-observability of intermediate states.
We will finish this section introducing the process specification of the reader class in TABLE 4:
reader = librarian : new_reader O = reader 0 ;
reader_0 = librarian:destroy_reader() + loan() reader 1;
reader-1 = if book_count=1 return() = reader_0 + (if book count > 1 return( ) + if book count < 10 loan U) =reader_i;.
The execution of processes are represented by terms in a well-defined algebra of processes. Thus, possible object lives can be declared as terms whose elements are transactions and events. Every process can be rewritten to a term in a basic process algebra BPA_Ss, with the = (sequence) and + (alternative) process operations.
This provides an implementation of concurrence based on arbitrary interleaving.
~
After having presented Conceptual Model and the OASIS formal concepts associated with them in accordance with one embodiment of the present invention, the mappings will now be discussed that generate a textual system representation 215 (that is a specification in OASIS) taking as input the graphical information introduced in the Conceptual Model. This formal specification 215 has in fact been obtained using CASE
tool 210, and constitutes a solid system documentation to obtain a final software product which is compliant with the initial requirements, as represented in the source Conceptual Model.
According to the class template introduced in the previous section, the set of conceptual patterns and their corresponding OASIS representation.
The system classes are obtained from the object model. For each class, there are a set of constant, variable or derived attributes; a set of services, including private and shared events and local transactions; integrity constraints specified for the class; and derivation expressions corresponding to the derived attributes. For a complex class (those defined by using the provided aggregation and inheritance class operators), the object model also provides the particular characteristics specified for the corresponding complex aggregated or specialized class.
The information given by the object model basically specifies the system class framework, where the class signature is precisely declared. The dynamic model uses two kind of diagrams, the state transition diagram and the object interaction diagram. From the state transition diagram, the following are obtained: event preconditions, which are those formulas labeling the event transitions; the process definition of a class, where the template for valid object lives is fixed. From the object interaction diagram, two other features of an OASIS class specification are completed: trigger relationships and global transactions, which are those involving different objects.
Finally, the functional model yields the dynamic formulas related to evaluations, where the effect of events on attributes is specified.
Having thus clearly defined the set of relevant information that can be introduced in a Conceptual Model in accordance with an embodiment of the present invention, the formal specification 215 corresponding to the requirements 200 provides a precise system V
repository where the system description is completely captured, according to the OASIS
object-oriented model. This enables the implementation process (execution model) to be undertaken from a well-defined starting point, where the pieces of information involved are meaningful because they come from a finite catalogue of conceptual modeling patterns, which, furthermore, have a formal counterpart in OASIS.
Automatic software production of a complete, robust application from a Conceptual Model to an implementation language (such as a third generation languages like C, C++, or Java) requires the Conceptual Model to be both correct and complete. In this section, the terms "correct" and "complete" have the following meanings dependent on the specific needs for the automated software production process system as:
A Conceptual Model is "complete" when there is no missing information in the requirements specification. In other words, all the required properties of the Conceptual Model are defined and have a value.
A Conceptual Model is "correct" when the information introduced in the Conceptual Model is syntactically and semantically consistent and not ambiguous. In other words, all the properties defined in the Conceptual Model have a valid value.
Referring back to FIG. 2, the validator 220 receives as input the formal specification 215 of the Conceptual Model using an Object-Oriented Formal Specification Language (such as OASIS) as high level data repository. From a formal point of view, a validated OASIS specification 215 is correct and complete because the specification 215 is formally equivalent to a dynamic logic theory, using a well-defined declarative and operational semantics.
Formal specification languages benefit from the ability of formal environments to ensure that formal specifications 215 are valid or can be checked to be valid.
Formal languages define a grammar that rules language expressiveness.
Two procedures are used for Conceptual Model validation. For completeness, validation rules are implemented by directly checking the gathered data for the Conceptual Model, e.g., a class must have name, one attribute being its identifier and one service. For correctness, an extended formal specification language grammar is implemented in order to validate the syntax and meaning of all the formulas in the Conceptual Model.
Coiu cm ESs More specifically, for completeness, all the elements in a formal specification language have a set of properties that both have to exist and must have a valid value.
Most of the properties are strictly implemented to have a full definition and valid values.
However, the CASE tool 210 allows, for easy of use during a model inputting, to leave some properties incomplete or with invalid values. These properties will be checked by the validator 220 to be complete (and correct) prior to any automatic software production process.
The elements which are used to validate a Conceptual Model are described next.
For each element it is stated if validation will be strict (e.g. when all his properties have to exist and must have a valid value at creation time) or flexible (e.g validation will be accomplished at a later time). Some properties are optional, (e.g. that may not exist) but if they are defined, they must be validated. These elements are given in TABLE 5:
- Class o Name. Strict o ID function Flexible o Attributes (at least one) Flexible o Services (at least Create service). Flexible o Static and Dynamic Integrity Constraints (optional) ^ Their formula Strict - Attribute o Name. Strict o Type (Constant, Variable, Derived). Strict o Data-type (Real, integer, etc). Strict o Default Value. Strict o Size (if proceeds) Strict o Request in Creation service. Strict o Null value allowed. Strict o Evaluations (variable attributes). Flexible o Derivation formula (derived attributes). Flexible - Evaluation o One variable attribute of a class Strict o One service of the same class Strict o Condition (optional). Strict o Formula of evaluation. Strict - Derivation o Formula. Strict o Condition (optional). Strict - Service o Name. Strict o Arguments.
^ argument's name Strict ^ data-type Strict ^ default value (optional) Strict ^ null value Strict ^ size (if proceeds) Strict o For a transaction, its formula. Flexible - Preconditions of an action o Formula. Strict ^ Agents affected by condition Strict - Relationship: Aggregation o Related classes (component &composite) Strict o Relationship name. Strict o Both directions Role names. Strict o Cardinality. Strict o Inclusive or referential. Strict o Dynamic. Strict o Clause "Group By" (Optional). Strict o Insertion and deletion events (if proceed) Strict - Relationship: Inheritance o Related classes (parent & child) Strict o Temporal (versus permanent) Strict o Specialization condition or events Strict - Relationship: Agent o Agent class and service allowed to activate. Strict - State Transition Diagram (STD) o All states of class (3 at least). Flexible - State in STD
o Name. Strict - Transition in STD
o Estate of origin. Strict o Estate of destination. Strict o Service of class. Strict Control condition (optional). Strict Trigger o Condition. Strict o Class or instance of destination. Strict o Target (self, object, class) Strict o Activated service. Strict o Service arguments' initialization (Optional) ^ Arguments' values Strict Global Interactions o Name. Strict o Formula. Strict User exit functions o Name. Strict o Return data-type Strict o Arguments, (Optional) = Argument's name Strict ^ Argument's data-type Strict COMPLETENESS
Some properties of components in formal specification languages are "well formed formulas" that follow a well-defined syntax. It is therefore, a requirement to ensure that all introduced formulas in the Conceptual Model were both syntactical and semantically correct.
Not all formulas used in the Conceptual Model have the same purpose.
Therefore, there will be several types of formulas. Depending of formula's type, the use of certain operators and terms (operands, like: constants, class attributes, user-functions, etc.) are allowed. A process and a set of rules in grammar to validate every type of formula in the Conceptual Model also exist.
More specifically, the Conceptual Model includes formulas of the following types as shown in TABLE 6:
{
- Default Value Calculation of o Class Attributes (Constant and Variable) o Service and Transaction Arguments - Inheritance: Specialization condition - Static and Dynamic Integrity Constraints - Derivations and Valuations:
o Calculation formula (Derived or Variable attributes respectively) o Conditions (optional) - Preconditions for actions (Services or Transactions) - Control Conditions for transitions in State Transitions Diagram - Triggering conditions .
- Local and Global Transactions formulas These formulas are validated at the time they are introduced, by preventing the designer from leaving an interactive textual dialog if formula is not syntactically and semantically correct.
a syntactically correct; every class must have In general, every formula must be ery an identification function; every class must have a creation event; every triggering formula must be semantically correct (e.g. self triggers to an unrelated class are forbidden); and every name of an aggregation must be unique in the conceptual schema. If these =
conditions are not satisfied, then an error is raised.
A warning may be raised, on the other hand, if any of the following do not hold:
every class should have a destroy event; every derived attribute should have at least a derivation formula; every service should have an agent declared to execute it;
and every argument declared in a service should be used.
Validation process will also be invoked every time the designer performs a change into the model that may invalidate one or more formulas. As mentioned earlier, for ease of use, certain type of formulas are allowed to be incorrect, which the designer will have to review at a later time. The automatic software production process in accordance with one embodiment of the present invention, however, will not continue to code generation, if not all the formulas are correct. Each time the designer introduces a modification in the Conceptual Model specification, all affected formulas will be checked. As a result, the following cases may happen:
1. If any of the affected formulas makes reference to a "Strict" property, the change will be rejected. An error will be raised to inform the designer.
2. If none of the affected formulas reference a "Strict" property, a modification to the Conceptual Model will be accepted. An action-confirmation dialog is displayed before any action is taken..
3. If there is no affected formula, modification is performed straightaway. In order to validate the user interface information, the validator 220 checks the following for errors: the patterns defined must be well constructed with no essential information lacking; the attributes used in filters must be visible from the definition class; the attributes used in order criteria must be visible from the definition class;
the formula in a filter must be a well-formed formula using the terms defined in the model; the action selection pattern must use as final actions objects defined in the Conceptual Model; and the set of dependency patterns must be terminal and have confluence. Warnings may be generated under the following conditions: if a pattern is defined but not used (applied), or if an instance pattern is duplicated.
Automatic software production from Conceptual Models requires these Conceptual Models to be correct and complete. Applying the characteristics and properties of formal specification languages makes it possible to effectively validate a Conceptual Model. The validation process is based on the grammar defined by the formal specification language, and partial validation is to be invoked any time the designer introduces modifications to the Conceptual Model specification. Prior to any automatic software production process, Conceptual Model will be validated in a full validation as a pre-requisite.
TRANSLATION OVERVIEW
The validated formal specification 215 is the source for an execution model that handles the implementation-dependent features associated with a particular machine representation. To implement the specified system, the way in which users interact with system objects is predefined. In accordance with one embodiment, the execution template presented in FIG. 6 can be used to achieve this behavior. FIG. 6 is a flow diagram illustrating the high level view of the operation of translating a formal specification into a full application by following what it is referred to as "execution model"..
The process starts by logging the user into the system and identifying the user (step 600). An object system view is provided (step 602), determined by the set of object attributes and services that the user can see or activate. After the user is connected and has a clear object system view, the user can then activate any available service in the user's worldview. Among these services, there will be observations (object queries), local services, or transactions served by other objects.
Any service activation has two steps: build the message and execute message if possible. In order to build the message, the user has to provide information to identify the object server (step 604). The existence of the object server is an implicit condition for executing any service, except for the service new. Subsequently, the user introduces service arguments (step 606) of the service being activated (if necessary) to build the message.
Once the message is sent (step 608), the service execution is characterized by the occurrence of the following sequence of actions in the server object. The state transition is checked (step 610) for verifying that a valid transition exists in the fonnai specification for the selected service in the current object state. The preconditions are checked for their satisfaction (step 612) for indicating that the precondition associated to the service must hold. If either of these actions does not hold, an exception will arise and the message is ignored.
Otherwise, the process continues with fulfilling the validations (step 614) where the induced service modifications take place in the involved object state. To assure that the service execution leads the object to a valid state, the integrity constraints (step 616) are verified in the final state. If the constraint does not hold, an exception will arise and the previous change of state is ignored. After a valid change of state, the set of condition-action rules that represents the internal system activity is verified. If any of them hold, the specified service will be triggered (step 618).
Accordingly, the steps illustrated in FIG. 6 guide the implementation of any program to assure the functional equivalence between the object system specification collected in the Conceptual Model and its reification in an imperative programming environment.
In one embodiment of the present invention, several translators may be used to complement the CASE tool 210 to constitute an automatic software production system.
In one implementation, for example, the translators produce an application in accordance with a three-tiered architecture suitable, for example, for Internet applications.
Particularly, three different translators arise, corresponding to each tier: a system logic translator 232, a user-interface translator 234, and a database generator 236.
In addition, a fourth translator is used, documentation generator 238. These different translators are characterized by the output produced and, though potentially having the same input, each translator focuses on a particular subset of information in the above mentioned high level repository 215.
SYSTEM LOGIC TRANSLATION
The system logic translator 232 automatically generates code for a third generation programming language from information in the high level repository.
The output of the system logic translator 232 corresponds with the middle-tier in a three-tiered architecture.
In one embodiment, the system logic translator 232 produces source code that covers the following: (1) communications subsystem with the user interface functions, (2) access to and communication with the persistence layer, (3) standard query services for reading the persistence layer contents, and (4) error handling produced by the persistence layer and client communications..
The communications subsystem is configured for receiving requests from a client, invoking internal methods, and returning replies to requestors, that verify the requestor's existence and authorization to perform the requested service; verify the existence and validity of the requested server instance; create a copy of the requested server instance in memory accessing the persistence layer for persistent attributes or calculating the value of derived ones ; validate state transition for the requested service as specified in the state transition diagram 400 in the Conceptual Model; verify that the requested service's preconditions hold; perform all valuations related to the requested service as specified in the functional model; verify constraints for the new state achieved by the requested server instance; check trigger conditions to execute the corresponding actions; and make changes in the requested server instance persistent.
In addition, code is generated for access to and communication with the persistence layer, service standard queries to read persistence layer contents, and handle errors produced by the persistence layer and communications with client in one implementation for examples the generated code may include scripting to create and drop tables, constraints, and indexes to define a data model in a Relational Database System (RDBMS) in accordance with the validated spcification 215 of the Conceptual Model..
In one embodiment, the first phase of code generation is the retrieval of information from the Conceptual Model 215 and storage of this information in code generation structures in memory. Three kinds of elements guide the retrieval of information: classes, global transactions, and global functions. Relevant information to be obtained from classes in the Conceptual Model include: name, constant attributes (name, type, requested upon creation, and initialization value formula), variable attributes (name, type, requested upon creation, initialization value formula, and null values admittance), derived attributes (name, type, and derivation formula), identification function, events (name, arguments: name and type, and precondition formula), transactions (name, type, j arguments: name and type, precondition formula, and transaction formula), valuation formulae, state transitions (initial state, final state, service name, valid agents, and transition condition formula), static constraints formulae, dynamic constraints formulae, trigger conditions formulae, ancestor class (name), specialized classes (name, specialization condition formula, precondition redefinitions, and valuation redefinitions), aggregation relationships (related class, cardinalities, static or dynamic, and role names), and population selection patterns (filter: name and filter variables, order criteria).
Relevant information to be obtained from global interactions in the Conceptual Model includes: name, arguments (name and type), and global interaction formula.
Relevant information to be obtained from global functions in the Conceptual Model:
include: name, return type, and arguments (name and type).
Generated code follows a component-based structure, based on the main unit of information that is found in the Conceptual Model, that is: the class. Each class in the Conceptual Model yields, in a first approach, several of software components.
For example, one component, referred to as a "server component" has an interface comprising a method for each service present in the signature of the corresponding class.
Another component, whose interface comprises the methods necessary to query the population of the corresponding class, is called a "query component." A
particular kind of executive component is the component relating to global interactions defined in the {
Conceptual Model, whose interface consists of a method per global interaction.
These components constitute the two access points the second or middle tier offered to the first or presentation tier. Server components receive requests from the presentation tier that relate to the execution of services, and query components receive requests from the presentation tier that relate with querying the persistence tier. This is appropriate for Internet-deployed applications, because this allows for context-free, scalable, transactional solutions. Nevertheless these are not the only components generated.
Another generated component directly related to a class of the Conceptual Model is the one called "Executive Component" and is responsible for resolving or executing each of the services in the signature of the corresponding class. This component receives request from its corresponding server component or from other executive components.
Since a main purpose of the executive component is to resolve the services offered in the class signature, the interface presented by the executive component to the other components comprises a method per service. Each of these methods is structured according to the execution model in accordance with an embodiment of the invention.
In other words, the executive component is responsible for the following operations: verify the existence and validity for the requested server instance; create a copy of the requested server instance in memory accessing the persistence layer (by means of the above mentioned corresponding query component) to retrieve the values of constant and variable attributes; validate state transition for the requested service and the present state of the requested server instance as specified in the corresponding state transition diagram in the Conceptual Model; verify the satisfaction of the requested service preconditions; modify the value of the instance variable attributes by performing all valuations affected by the service as specified in the functional model of the Conceptual Model, thus changing the state of the requested server instance;
validate the new state achieved by the requested server instance by verifying its static and dynamic restrictions; check trigger conditions to determine which actions should be triggered if needed; communicate with the persistence layer for all persistent attributes of the requested server instance. Additionally, if the class is an agent of any service, another method is added to the interface whose purpose is that of validating the requestor's existence.
Another kind of executive component is a component related to global interactions defined in the Conceptual Model, whose interface consists of a method per global interaction.
If the class belongs to an inheritance hierarchy, all executive components of the same hierarchy are grouped into a single, special executive component.
Nevertheless there would still be one server component per class in the hierarchy.
Another component to which a class in the Conceptual Model gives rise is a component called the "T component". This component is used to store a copy of the constant and variable attributes of an instance of the corresponding class, as well as the methods to calculate the value of its derived attributes. The corresponding query component implements a collection whose items are T components.
Another component to which a class in the Conceptual Model may give rise is a component called "P component". This component is used to store in memory the values needed to initialize the constant and variable attributes of the corresponding class when creating an instance of it, or just the values of the attributes that constitute the class identification mechanism. Such a component appears whenever the corresponding class is a multi-valued component of an aggregation relationship.
Another component to which a class in the Conceptual Model may give rise is a component called "PL component". This component implements a collection whose items are P components, as well as the methods needed to add and get items from the collection, and get the number of items in the collection. Such a component appears whenever the corresponding class is a multi-valued component of an aggregation relationship.
Another component to which a class in the Conceptual Model may give rise is a component called "C Components". This component is used to store in memory the values needed to initialize the constant and variable attributes of the corresponding class it when creating an instance of it. Such a component appears whenever the corresponding class is a temporal or permanent, condition-based, specialization.
Additional components includes a CC component, an error component, a trigger component, a trigger list component, an instance list component, and condition, disjunction, and conjunction components.
The CC component appears whenever there is, at least one temporal or permanent, condition-based, specialization in the Conceptual Model. The CC
component implements a collection whose items are C components, a pair of methods to add and get items to the collection (one pair per C component generated), and a method to get the number of items in the collection.
The error component always appears and is used to store information about the success or failure of a service execution. The trigger component stores information about a satisfied trigger condition so that the corresponding action can be later executed. The trigger list component implements a collection whose items are trigger components, as well as the methods to add an item to the collection, get any item from the collection, get the first item and get the number of items in the collection.
The instance list component implements a collection whose items are executive components playing in the execution of a given service. In addition to methods used to add an item to the collection, get an item, and get the number of items in the collection, this component implements a method to empty the collection and another one to look for aninstance by its identification function.
The condition, disjunction and conjunction Components are always generated and support the construction of complex boolean expressions, used to query the persistence layer, structured as a conjunction of disjunctions. The condition component stores information about a simple boolean condition, that is: two operands and an operator (+, -, o, <, <=, >_, > ...). The disjunction component implements a collection whose items are condition components (that is, a disjunction of conditions), as well as methods to add and get a condition from the collection and a method to get the number of conditions in the collection. The conjunction component implements a collection whose items are disjunction components (that is, a conjunction of disjunction), as well as methods to add and get a disjunction from the collection and a method to get the number of disjunctions in the collection.
In addition, two modules are also generated: a global module for grouping attributes and methods shared through the generated code, and a global functions module that groups the code of all global functions defined in the Conceptual Model.
TRANSLATION STRATEGY AND ARCHITECTURE
In accordance with one embodiment, code generation is driven by the information retrieved from the high level repository 215. The translation process can be divided into four phases: validation of the Conceptual Model (performed by validator 220), translation of the corresponding data model into a relational database management system (performed by database generator 236), retrieval of information from the Conceptual Model and storage of this information in memory structures and finally, generation of files from the information stored in memory (e.g. reading the information in memory structures to generate code in the target programming language).
Validation of the Conceptual Model is mandatory, while data model translation is optional, but both can be considered as prerequisites to the other two phases which are the ones strictly related to code generation. Translation structures are designed to store input information from the Conceptual Model and all have a method that uses this information to generate. source code in the target programming language.
These translation structures include: a class to store information needed to generate server components (server class), a class to store information needed to generate server components for global interactions (global interactions server class), a class to store information needed to generate executive components (analysis class), a class to it store information needed to generate executive components for global interactions (global interactions analysis class), a class to store information needed to generate executive components for inheritance hierarchies (inheritance hierarchy analysis class), a class to store information needed to generate query components (query class), a class to store information needed to generate T components (T class), a class to store information needed to generate C components (C class), a class to store information needed to generate CC component (CC class), a class to store information needed to generate P
components (P class), a class to store information needed to generate PL
components (PL
class), a class to store information on the arguments for every service of every class in the Conceptual Model (arguments list class), a class to store information on the identification function of every class in the Conceptual Model (analysis class list class), classes to generate the methods needed to resolve a service in executive components (event class, shared event class, transaction class, interaction class), classes to generate the auxiliary methods needed to resolve a service in both executive components and executive components for inheritance hierarchies (precondition class, static constraints class, dynamic constraints class, ...etc.). classes to generate methods needed in query and T
components (T & Q method classes), a class to generate inheritance-specific methods (inheritance method class), and a class to monitor the generation process (code generation class).
The code generation class is responsible for retrieving all the information needed to generate code and for doing so in the appropriate order, for writing to files the generated code and organizing it into files properly according to the component-based structure. The code generation class maintains lists of the above mentioned generation structures in memory in which information retrieved from the Conceptual Model is to be stored and it later loops through these lists to write the appropriate files.
The information retrieval process basically comprises a series of loops through the classes in the Conceptual Model to gather all information needed, a loop trough global interactions and a loop through global functions in the Conceptual Model.
The last phase in the code generation process covers writing to files according to the component-based structure presented herein. This process comprises:
looping through the lists of instances above described that maintain the information needed to generate components and their attributes and methods, and call each element's code generation method; generating global interactions executive component;
generating global interactions server component; generating global functions module; and generating standard components.
For each global function a method is generated. The method has the same name as the global function and a translated return type. Each argument of the method has the same name of the corresponding argument of the global function and a translated type.
USER-INTERFACE TRANSLATION
In one embodiment, where the user-interface translator 234 automatically generates source code for a high order programming language such as Visual BASIC or JAVA from information in the high level repository. However, code may be generated in any computed language. Its output corresponds with the presentation tier in a three-tiered architecture. Thus, the user-interface translator 234 provides as output the source code of a component that implements the user interface functionality. This component is automatically generated without human intervention. The user-interface translator 234 uses as input data a validated Conceptual Model 215 and offers as output data, source code in a third generation language that implements an equivalent functional prototype related to the Conceptual Model the component is derived from.
In one embodiment of the present invention, the user-interface translator 234 produces source code to perform the following: a communications subsystem able to send {
requests to a business component, and receive replies; a logon to system for user authentication; and a menu of available services for specific authenticated user. For each available service, frame, screen or data collection dialog of all service arguments, the user-interface translator 234 generates code that sets initial values for arguments, validates introduced data (type, range, object existence, etc.), and calling to server activation. In addition, the user-interface translator 234 generates code for standard query services that list all instances status in a class and error handling.
Additionally, code is generated for a wider and flexible user-interface operation.
In a query service frame, form or screen, the following functionality will be available when a certain instance has been selected: navigation through relationships with related selected object. This navigation is used to browse among related data items following its related links; thus, the resultant code is suitable for Internet applications.
Additional functionality includes services activation for selected object; advanced query services including: filters (population selection), views (status selection), and sorting criteria; and context keeping for filling-in known services arguments. Context keeping is a user-facility. Context is data associated to the working user environment. This data is useful to provide default values for service arguments.
For its input, the user-interface translator 234 reads specification 215 of a Conceptual Model and stores this kind of information in intermediate structures in memory. The user-interface translator 234 is independent of the input medium in which III
the Conceptual Model is provided. In this way, the intermediate structures can be loaded from different data sources. The model is iterated in several passes to extract the relevant information in each phase of the translation process from the formal specification, including information about classes, aggregation relationships, inheritance relationships, agent relationships, global interactions, user defined functions, and interface patterns.
Translated applications are composed by forms that contain the user-interface offered to final user. A form, in abstract sense, is the interaction unit with the final user.
Forms are translated depending on capabilities of the target environment to match the requirements: e.g. windows dialogues for Windows environments, HTML pages in Web platforms, applets in Jav, etc.
Translated applications supply the user connection to the system. The user connection is resolved using an access form to authenticate the agent. In addition, the translated application provides a system user view. A user must be able to access services the user can launch. The main form is designed to accomplish this task.
For each service that can be executed by a user, the translated application generates an activation service form. For each class, the translated application generates a query / selection form. This form allows users to query data instances, search instances that fulfill a given condition, observe related instances and know which services can be launched for a given object in its current state. For each service, the translated application furnishes initialization values for object-valued arguments.
Initial data is also provided by managing information obtained from the browse made by the user.
The user encounters different scenarios interacting with the application.
These scenarios lead to define different types of forms. In the next section, each kind of form will be described.
In the Conceptual Model 215, some classes are defined as agents of services classes (called agent classes). That is, if an object is a service agent it is allowed to request the service. Each agent object must be validated authenticated before trying to request services. The Access Form requests an agent class (selected from a list of valid agents classes), an object identifier and a password. The data collected is used to verify if there exists a valid agent object that is allowed to access the system.
The Application Main Form contains a menu, where user can view the services he is allowed to execute. The source code associated to each action realized by user is automatically generated.
ii For each accessible service for at least one agent, a Service Form is generated.
These forms have an introduction field for each argument the user must provide. This argument's fields have attached code to validate data types, sizes, value-ranges, nulls, etc. Object-valuated fields provide facilities to search the object browsing information and filtering it. Code is generated to accomplish this task.
Each service argument can take its initial value in three different ways:
1. By Initial values. In the Conceptual Model, the designer can provide default values for attributes and arguments. If such value exists, code must be generated to supply the value.
2. By Context. Context information (for example, a list of recently observed objects) is useful to suggest values to object-valuated arguments that have the same type that collected ones. A function is generated to search appropriate values in the recently visited objects list.
3. By Dependency Pattern. In the Conceptual Model, the system designer can define Dependency Patterns. The Status Recovery pattern is an implicit set of dependency patterns too. In both cases, the change on an argument, can affect to values in another ones. So, certain argument values can be initially fixed in this way.
Data Validation can occur just after data input, interactively warning the user and just before sending data to system-logic. Object-valuated arguments validation requires {
checking object existence. To support validation, a function is generated for each service argument. The function is invoked before sending a request to system-logic.
When the user requests service execution, the service arguments are validated.
If the service arguments are valid, system logic is invoked to accomplish the service. The message built to invoke the system-logic uses the formal order to sort the arguments.
After executing the service, the user is informed whether the service succeeded or not.
This transactional approach is ideal for Internet applications. Accordingly, code to validate arguments and Code to invoke the system-logic with necessary arguments in the formal order are generated. Furthermore, possible errors are returned to inform the user.
The Query/Selection Form permits the querying of objects (that can be restrained -by filters) and the selection of an object. When an object is selected, the user can browse to other data items related to the object. In the same way, the user can launch a service of the selected object.
These query/selection forms include graphic items representing filters. A
visual component is used to filter the population of a class. Filters may contain variables. In such cases, fields for the variables are requested to users in order to form the condition of the filter.. For example: Find cars by color, by type and model.
These query/selection forms also include a visual component to show objects.
Inside this component objects that fulfill the filter condition (or every class population if filters are not defined) appear. The attributes displayed in the component are set by a Display Set.
These query/selection forms also include a visual component to launch services.
For example: given a car, the user can launch services in order to rent the car, return, or sell it. This task is achieved by a function that determines which service to launch of what object The corresponding Service Form is invoked for each exposed service. These query/selection forms also include a component to initiate the browsing. For example:
given a car, the user can view the driver, the driver's sons, etc. When the user navigates (follows a link from an object) a new query/selection form is displayed. In the same way that the previous component, there exists code to invoke the next form to display when user browses objects. When a query/selection form is reached by navigation, the form receives information about the previous object in order to display only the data related to that initial object.
In the applications, visited objects and navigation paths followed by users are stored. This information is named Context Information. When the user browses data between query/selection forms, the path followed is stored. Finally, when the user tries to invoke a service and a service form is needed, the application can provide, as an extra input to the service form, this contextual information. Then, the Service Form uses this data to provide initial values for object-valuated arguments.
USER-INTERFACE TRANSLATOR ARCHITECTURE
Using the Conceptual Model 215 used as input, the user-interface translator can retrieve information from memory structures, a relational database, using a query API
or any other input source. An intermediate structure in memory is filled with the Conceptual Model data relevant for translating the user-interface component.
Intermediate structure follows an architecture to the one defined in the Conceptual Model schema in which can be queried for classes, services, and attributes for a specific Conceptual Model.
When data is loaded in the intermediate structure, the real translation phase begins. Inside the source code files of the generated application, two types of files can be distinguished. One type of files is a set of files having fixed contains.
These files correspond to structures or auxiliary functions widely used that are always produced in the same way. These files are generated by dumping byte streams directly from the translator to final files in order to create them. Other files strongly depend from the Conceptual Model that is being processed. Therefore, although these files have a well-defined structure (detailed in the previous section), they have variable parts depending on the processed model. The user-interface translator 234 iterates the Conceptual Model to extract the relevant data to generate these variable parts.
The translation process for the user-interface translator 234 has the following tasks:
1. Generate the fixed files, e.g. headers, definitions, constants, and auxiliary functions to its respective files.
2. Generate auxiliary widgets (controls or Java Beans) depending on the application 3. For each class, generate a query / selection form, an instance selection component, a specialization component (if class is specialized from other class an requires extra initialization). For each service class, also generate a service form.
4. Generate an access form (identification).
5. Generate a main form containing the menu application.
6. Generate communication functions to reach system-logic server. These functions encapsulate the invocation of services available in the prototypes.
The Access Form is a little dialog box containing: a list of agent classes (from this list, the user chooses one), a field where the user provides OID for a valid object instance belonging to the previously selected class and a field for password. This form is mostly generated in a fixed way. The only varying section for each model is the mentioned agent classes list. By iterating over the model classes list and by checking which classes are agents such agent classes list can be obtained.
In order to provide access to the application's functionality, the services are arranged in an access-hierarchy to be converted to menu bars (Visual Basic client), HM
pages (Web client) or any other structure that allows browsing. By default, the hierarchy is built by iterating the classes and services in the Conceptual Model. The hierarchy can bee seen as an access tree to the application. For each class a tree item is built labeled with class alias. For each built-in item this mode has the following items as descendents:
an item labeled as `Query' to access a query form; an item for each service defined in the current class labeled with the service alias; and, in the case of inheritance relationship with other classes, an item is built for each direct subclass labeled with subclass alias.
Recursively, the same algorithm is applied until the inheritance tree is fully explored.
A Service Form requires the following input data extracted from the Conceptual Model: Service to generate, service class, arguments list, interface patterns linked to arguments. For each service, a form is generated that contains a graphic part and a functional part. The graphic part includes a widget attached to each argument that needs to be asked to user and a pair of widgets to accept or cancel the service launch. The functional part includes code to implement the event-drivers for the previous widgets, to initialize the properties of theses widgets with default values, to validate introduced values, and to invoke the service in the system-logic component.
A detailed explanation of how to generate a Service Form follows. First, two argument lists are obtained. The first one corresponds to the arguments defined in the ICI
service declaration (FL, Formal List). In this list the arguments are sorted by its formal declaration order. The second one contains the same arguments sorted by the presentation order (PL, Presentation List). Both orders are specified in the Conceptual Model.
Iterating through the formal List and for each argument: create a widget for each argument that has to be requested to user and set relevant properties to arguments like:
type, size, can be null, Introduction Pattern, Defined Selection Pattern or Population Selection Pattern Widgets are added for OK and Cancel commands, and graphic positions of widgets are arranged so they do not overlap. In one implementation, the form is divided in a logical grid of n columns by n rows and assign positions from left to right and from top to bottom to conveniently arrange the widgets. The logical positions are translated to physical position in the target language and rearrange action commands in the bottom-right comer of the form. Finally, the form is resized to adjust the size of data contained therein.
For output, the standard header of a form is dumped to a file. This step is dependent of the target language selected. Then, the graphic part of form is dumped to the file, including the definition of basic form properties, the definition of each widget., and the widgets' actions.
Finally, the source code attached to this form is translated and dumped. This process includes translating generic functions to manage events in the form, such as open and close events and produce code to assign and free resources. Also, functions to handle the Status Recovery Pattern and dependencies between widgets are translated.
Depending on the Status Recovery Pattern attached to the service, and possible Dependency Patterns defined in the service, code for changing argument values must be generated and the code that triggers such dependencies. The validation code is also translated too.
There are validation methods to check the values gathered in the widgets are right.
Finally, a function to translate service calling into invocation to system-logic services is generated.
The function built contains: a reference to system-logic object where the service is going to be executed; the invocation to a method that implements the service in the system-logic; and the arguments necessary to such function, constructed from values supplied form user through widgets.
In order to generate a query/selection form, the following Conceptual Model information is required: a class and its properties (alias), and the list of the Population Selection interface patterns defined for the class. Each pattern contains: a display set, a filter, and a sort criterion. In case there is no visualization set defined, the list of attributes belonging to the class is assumed. If a class lacks a population selection pattern, the following default values will be assumed: every attribute defined in the class is considered as part of the display set, and neither a filter (in this case the whole population of the class is returned) nor a sort criteria are attached.
Generating a query/selection form also requires information about the relationships of the class. For every class, a form is generated based on this information and contains a tabular representation of the display sets of the class, a set of grouped filters that allow to restrict search through the population, and a pop-up menu including navigability links to the classes related to the first one and available services to be launched over instances of the class.
The generated software component, which has been described before, provides the user-interface client functionality that includes all the required functionality for both validating and executing a prototype compliant to the Conceptual Model it has been derived from. The applications of the component are: prototyping, user validation of the Conceptual Model before capturing new requirements; testing to validate the Conceptual Model by analysts to verify that the model faithfully reflects the requirements; and ultimate application production, once the process of requirements capture is completed, the generated component can be considered as a final version implementing a functionally complete and ergonomic user interface. The component can be edited to customize the application to users desires with very little effort.
DATA MODEL TRANSLATION
In one embodiment, the database generator 236 automatically defines a data model in a Relational Database Management System (RDBMS) according to the validated specification in the high level repository 215. However, other forms of persistent storage may be used. Such as flat files, serialized files or Object Oriented databases. The output of the database generator 236 output corresponds with the persistence tier in a multi-tiered architecture. .
From the information in the high level repository about a given Conceptual Model, scripts are generated in order to create and delete tables, constraints (primary and foreign keys) and indexes. Scripts can optionally be executed in a Relational Database Management System to effectively create said data model.
From the point of view of relational databases, data is stored in tables with relationships between them. However, from the object oriented programming point of view, data is stored in object hierarchies.
Although the automatic software production system in accordance with one embodiment of the present invention is based on an object oriented methodology, it is necessary to find a physical data storage system to permanently store data managed by generated applications. Relational databases are preferred, because they are the industry-standard way to store data and, consequently, use of tables instead of objects as it would be desirable. Nevertheless, many object-oriented applications, like those produced by in accordance with an embodiment of the present invention, can be compatible with the Relational Model, since the static aspects of objects can be stored in tables following a translation process.
The generated data model comprises a set of tables and the corresponding relationships, as well as constraints on primary and foreign keys and indexes.
The generated data model reflects system data with the attributes defined in the classes specification and other class instances properties like their state, role if they are agents.
Information, gathered from the high level repository 215 and needed to produce the corresponding data model, focuses on classes and include the name, constant attributes (either emergent or inherited); variable Attributes (either emergent or inherited); identification function; inherited identification function;
aggregation relationships (either emergent or inherited); and agent information.
Preferably, the generated scripts follow a standard: ANSI SQL 92. This fact means that the generated data model can fit any database management system based on ANSI SQL 92, particularly most well known relational database management systems.
The process to obtain the data model follows these steps: For each elemental class of the Conceptual Model, a table in the selected relational database is created. For each constant or variable attribute in the class specification, a field in the table corresponding to the class is created. The field data type depends on Conceptual Model attribute data type translated into the target relational database. Derived attributes are not stored in the database since their value will be calculated upon request by special methods in the server code generated.
Primary keys are determined by attributes marked in the Conceptual Model as being identification attributes. Thus table fields corresponding to these attributes will constitute the primary key of the table. As a particular case, tables corresponding to specialized classes, in addition to fields representing emergent attributes, have fields that correspond to attributes that constitute the primary key of the table representing their ancestor class. If a specialized class does not have an identification function of its own, these fields, copied from the ancestor class, constitute the specialized table primary key.
At the same time, they constitute the foreign key to the parent class table.
On the other hand, if a specialized class has its own identification function, these fields only constitute a foreign key to the parent class table.
Aggregation case is more complicated, because aggregation has more dimensions.
The aggregation relationship dimensions determine its cardinalities that in turn determine representation in the database: If the relationship is multi-valued (maximum cardinality set to M) in both senses a new table is added in order to represent this aggregation relationship. This table has a field for each one that constitutes the primary key of related tables. The set of all this fields constitutes the primary key and, individually, fields coming from each related table's primary key, constitute foreign keys to each related table.
If the relationship is uni-valued (maximum cardinality set to 1) in one sense, the class related with only one instance of the other one copies the fields of the primary of the other one. These fields constitute a foreign key to the related class table.
If the relationship is uni-valued in both senses, any of the tables could have the foreign key to the other. The adopted option in this case is that the aggregate class have the reference to the component class. With respect to minimum cardinalities, if minimum cardinality is 0 then the corresponding field will take null values. Otherwise it will not. If identification dependence exists between two classes then fields of the primary key of the non-dependent class are copied to the table corresponding to the dependent class. They
The instructions received by main memory 106 may optionally be stored on storage device 110 either before or after execution by processor 104.
Computer system 100 also includes a communication interface 118 coupled to bus 102. Communication interface 118 provides a two-way data communication coupling to a network link 120 that is connected to a local network 122. For example, communication interface 118 may be an integrated services digital network (ISDN) card or a modem to provide a data communication connection to a corresponding type of telephone line. As another example, communication interface 118 may be a local area network (LAN) card to provide a data communication connection to a compatible LAN.
Wireless links may also be implemented. In any such implementation, communication interface 118 sends and receives electrical, electromagnetic or optical signals that carry digital data streams representing various types of information.
Network link 120 typically provides data communication through one or more networks to other data devices. For example, network link 120 may provide a connection through local network 122 to a host computer 124 or to data equipment operated by an Internet Service Provider (ISP) 126. ISP 126 in turn provides data communication services through the worldwide packet data communication network, now commonly referred to as the "Internet" 128. Local network 122 and Internet 128 both use electrical, electromagnetic or optical signals that carry digital data streams. The signals through the various networks and the signals on network link 120 and through communication interface 118, which carry the digital data to and from computer system 100, are exemplary forms of carrier waves transporting the information.
Computer system 100 can send messages and receive data, including program code, through the network(s), network link 120, and communication interface 118. In the Internet example, a server 130 might transmit a requested code for an application program through Internet 128, ISP 126, local network 122 and communication interface 118. In accordance with the invention, one such downloaded application provides for automatic software production as described herein. The received code may be executed by processor 104 as it is received, and/or stored in storage device 110, or other non-volatile storage for later execution. In this manner, computer system 100 may obtain application code in the form of a carrier wave.
CONCEPTUAL OVERVIEW
FIG. 2 is a schematic block diagram illustrating the high-level architecture and data flows of an automatic software production system 202 in accordance with one embodiment of the present invention. The automatic software production system 202 is configured to accept requirements 200 as input, and produce a complete, robust application 204 (including both system logic and user-interface code), a database schema 206, and documentation 208. In one implementation, the automatic software production system 202 includes a Computer Aided Software Engineering (CASE) tool 210 front end to allow a user to input the requirements, a validator 220 for validating the input requirements 200, and several translators to convert the validated input requirements 200 into a complete, robust application 204. These translators may include a system logic translator 232, a user-interface translator 234, a database generator 236, and a documentation generator 238.
During operation of one embodiment, requirements 200 specifying a Conceptual Model for the application are gathered using diagrams and textual interactive dialogs presented by the CASE tool 210. Preferably, the CASE tool 210 employs object-oriented modeling techniques to avoid the complexity typically associated with the use of purely textual formal methods. In one implementation, the Conceptual Model is subdivided into four complementary models: an object model, a dynamic model, a functional model, and a Presentation Model. These models are described in greater detail hereinafter. After gathering the requirements 200, the CASE tool 210 stores the input requirements as a formal specification 215 in accordance with a formal specification language, for example, the OASIS language, which is an object-oriented language for information systems developed at the Valencia University of Technology in Spain.Using extended grammar defined by the formal language, the validator 220 syntactically and semantically validates the formal specification 215 to be correct and complete.. If the formal specification 215 does not pass validation, no application is allowed to be generated; therefore, only correct and complete applications are allowed be generated.
If, on the other hand, the formal specification 215 does indeed pass validation, automatic software production processes, some of wich are referred to as "
translators"
(system logic and user interface ones), are employed to implement a precise execution model that corresponds to the validated formal specification 215.. In particular, translators 232 and 234 produce application source code 204 in a high-order language such as C++, Visual Basic or JAVA for the application's system-logic and user-interface, respectively. In one implementation, a database generator 236 also produces instructions in, for example, a Structure Query Language (SQL) scripting language to create the data model for the application in an industry-standard ANSI-92 SQL Relational Database Management System (RDBMS).
In addition, one implementation also employs a document generator 238 to automatically generate serviceable system documentation from the information introduced in the Conceptual Model.
CASE MODELER
As mentioned herein above, the CASE tool 210 preferably employs object-oriented modeling techniques to avoid the complexity typically associated with the use of purely textual formal methods. Rather, four complementary models, that of the object model, the dynamic model, the functional model and the Presentation Model, are employed to allow a designer to specify the system requirements. In contrast with conventional techniques, however, the CASE tool 210 actually captures a formal specification of the designer's system "on the fly" according to a formal specification language, while the designer is specifying the system with the CASE tool 210..
This feature enables the introduction of well-defined expressions in the specification, which is often lacking in the conventional methodologies. In particular, the CASE tool 210 enforces the restriction that only the information relevant for filling a class definition in the formal specification language can be introduced. The use of a formal specification, input by means of the CASE tool 210, therefore provides the environment to validate and verify the system in the solution space, thereby obtaining a software product that is functionally equivalent to the specification as explained hereinafter. Nevertheless this is always done preserving this external view, which is compliant with the most extended modeling techniques, as stated before. In this way, the and formalism characteristic of many conventional approaches is hidden from the designer, who is made to feel comfortable using a graphical modeling notation.
With respect to the notation, conceptual modeling in one embodiment employs diagrams that are compliant with the Unified Modeling Language (UML); thus, system designers need not learn another graphical notation in order to model an information system. In accordance with a widely accepted object oriented conceptual modeling principles, the Conceptual Model is subdivided into an object model, a dynamic model, and a functional model. These three models, however, are insufficient by themselves to specify a complete application, because a complete application also requires a user interface. Therefore, the CASE tool 210 also collects information about user-interface patterns, in a fourth model referred to as "Presentation Model", which will be translated into the code for the application. In one embodiment, the CASE tool 210 collects information organized around projects that correspond to different applications. Each project built by the CASE tool 210 can include information about classes, relationships between classes, global transactions, global functions, and views.
Each class contains attributes, services, derivations, constraints, transaction formulas, triggers, display sets, filters, population selection patterns, a state transition diagram and formal interfaces.. In addition to the information in these lists, a class can also store a name, alias and a default population selection interface pattern.
Extra information is stored as remarks that the designer can input information about why a class does exist in a model.
Each attribute can have the following characteristics: name, formal data type (e.g. fl constant, variable, derived), data type (real, string...), default value, whether the attribute is an identifier for distinguishing the objects of the class, length, whether the attribute is required when the object is created, whether the attribute can be assigned a NULL value, and a field to introduce some remarks about why the attribute has been created. Each attribute can also include information about valuations, which are formulas that declare how the object's state is changed by means of events. Valuation formulas are structured in the following parts: a condition (that must be satisfied to apply the effect), an event and an effect of the event to the particular attribute. An attribute may also include user interface patterns belonging to the Presentation Model to be applied in the corresponding services arguments related to the attribute. {
Services can be of two types: events and transactions. Events are atomic operations, while transactions are composed of services which can be in turn events or transactions. Every service can have the following characteristics: name, type of service (event or transaction), service alias, remarks and a help message. Events can be of three types: new, destroy, or none of them. Events can also be shared by several classes of the project. Shared events belong to all classes sharing them. Transactions have a formula that expresses the composition of services. In addition to this information, services store a list of arguments whose characteristics are: name, data type, whether nulls are allowed as a valid value, whether the argument represents a set of objects (collection), default value, alias and remarks. Additionally, for each argument, user-interface patterns related to arguments are: introduction pattern, population selection pattern, defined selection pattern and dependency pattern. The class can also store information about derivations, and constraints. Each derivation specifies a list of pairs condition-formula, specifying which formula will be applied under every condition. Each constraint is a well formed formula plus the error message that will be displayed when the constraint was violated.
For the dynamic constraints, the formula will be internally translated into a graph which constitutes the guide for its evaluation.
A class can also store triggers. Each trigger may be composed of trigger target specified in terms of self, class or object, trigger condition, triggered action (service plus a list of possible agents) to be activated and a list of default values associated with the arguments of the related service. A class can also have display sets, filters and population selection patterns as user-interface patterns of the Presentation Model affecting the class.
Each display set can store elements of visualization (attributes to be displayed to the user). Each filter is composed of a well formed formula and a list of auxiliary variables that are useful to define the formula. The population selection pattern is related to a display set and a filter. Classes also have a State Transition Diagram that is a set of states and transitions between them. Each state transition is related to an action (service plus list of possible agents) that can change the state of the object. Actions may have preconditions and the corresponding error message (to be displayed if the precondition does not hold). Preconditions are formulas that need to be satisfied in order to execute the corresponding action. In case of non-deterministic transitions, determinism is achieved by means of labelling each transition with a control condition. A control condition is a formula that specifies which state transition will take effect. Finally, a class can store a list of interfaces. Each interface stores the list of services that an actor can execute (agents) and the list of attributes that can be observed.
The model also maintains information on relationships between classes, which can be of two types: aggregation ("has a" or "part of") and inheritance ("is a"). Each aggregation relationship indicates composition of objects and captures the information about cardinalities (numbers of minimum and maximum participants in the aggregation relationship, whether the aggregation is static or dynamic, whether the aggregation is inclusive or referential, whether the aggregation has an identification dependence, and a grouping clause when the aggregation is multi-valued. Each inheritance relationship indicates specialization of objects and stores the name of the parent class, the name of the child class and whether the specialization is temporary or permanent. Finally, if the specialization is permanent it stores a well-formed formula on constant attributes as specialization condition. If the specialization is temporary it stores either condition or the list of events that activate/deactivate the child role.
Finally, the project can also capture a list of global transactions in which the relevant characteristics to be stored include the name of the global interaction, the formula, and the list of arguments. A list of global functions can also be captured, in which each function stores a name, a data type of the returned value, a set of arguments (similar to services), and comments about the function.
A project may have a set of views, wich constitute the particular vision that a set of selected agent classes has of the system. That is, the set of formal interfaces (attributes and services) allowed per agent class. Each agent class has a list of interfaces.
OBJECT MODEL
The object model is a graphical model that allows the system designer to specify the entities employed in the application in an object-oriented manner, in particular, by defining classes for the entities. Thus, the class definitions include, for example, attributes, services and class relationships (aggregation and inheritance).
Additionally, agent relationships are specified to state that services that objects of a class are allowed to activate.
FIG. 3 illustrates an example of an object model 300 for a library system with readers, books, and loans. Classes, in the object model 300, are represented as rectangles with three areas: the class name, the attributes and the services. In the example, the object model 300 includes a loan class 310 with attributes to indicate a load code 312 and a loan date 314 for when the loan was made. The loan class 300 also includes two services (methods) including one for loaning a book 316 and another for returning the book 318.
The object model 300 also includes a book class 320 having attributes that specify the author 322 of the book, a book code 324, and a state 326 (e.g, reserved, in circulation, checked out, etc.) and services such as new book 328 for creating a new book.
Another class is a librarian class 330, whose name 332 is specified by an attribute and whose creation is done by a new librarian service 334.
Each reader belonging to the library is described with the reader class 340, whose attributes include the age 342, the number of books 344 checked out by the reader, and the name 346 of the reader. Readers may be created with a new reader service 348. An unreliable reader class 350 is also part of the object model to indicate for those readers 340 who cannot be trusted (e.g. due to unpaid fees for overdue books). An unreliable reader 350 may be forgiven 352 by a librarian 330.
In an object model 300, inheritance relationships are represented by using arrows to link classes. For example, the unreliable reader class 350 is connected to the reader claim 340 with an arrow; thus, the unreliable reader class 350 is specified to inherit from, or in other terms is a subclass of, the reader claim 340. The arrow linking the subclass and the base class can be leveled with a specialization condition or an event that activates or cancels the child role. In the exemplary object model 300, the arrow between the unreliable reader class 350 and the reader class 340 is labeled with a "reader.punish/forgive" service. Thus, if a reader 340 is punished, that person becomes an unreliable reader 350. Conversely, if an unreliable reader 350 is forgiven 352, that person becomes a normal reader 340.
Aggregation relationships are represented in the object model 300 by using a line with a diamond from a given component. class to its composite class with the diamond on the composite side. The aggregation determines how many components can be attached to a given container and how many containers a component class can be associated with. In the example, a book 320 and a reader 340 are aggregated in a loan 310, because a loan 310 involves lending a book 320 to a reader 340 of the library. The representation of aggregation also includes its cardinalities in both directions (i.e.
minimum and maximum numbers), role names, and relationship name. In the example, the cardinality of the loan:book relationship from loan to book is 1:1 because exactly one book is the subject of exactly one loan in this Conceptual Model, and from book to loan is 0:1 because a book may or may not be lent at any moment."
Furthermore, agent relationships are represented by dotted lines that connect the associated client class and services of the server class. In the example, a librarian 330 is an agent of a forgive service 352 of the unreliable reader class 350; thus, there is a dotted line between the forgive service 352 and the librarian class 330. This means that a librarian can forgive unreliable readers. As another example, readers 340 are agents of the loan book 316 and return book 318 services.
Finally, shared events are represented by solid lines that connect the associated events between two classes. In the example, the loan book event is a shared event due to the solid line connecting said events in the book class 320 and the reader class 340. A
shared event affects more than object, in which each object may change its state in accordance with its local specification. In the example, the loan book event causes the state of the book 320 to be changed to "not available", the number of books of the reader 340 to be incremented, and create an instance of the loan class 310, aggregations of the book 320 and the reader 340. Since the loan book event creates an instance of loan class 310, it is a "new" event for that aggregated class.
Additional information in the object model is specified to complete the formal description of the class. Specifically, for every class in the object model, the following information is captured as shown in TABLE 1.
Attributes All the aforementioned properties and/or characteristics Services All the aforementioned properties and/or characteristics Derivations Derivation expressions for the derived attributes (those whose value is dependent on other attributes) Constraints Well-formed formulas stating conditions that objects of a class must satisfy Complex specific information associated with aggregation and inheritance Relationships hierarchies Agents Services that can be activated by this class Additional information associated with aggregation and inheritance is also collected. For aggregated classes, the additional information can specify if the aggregation is an association or a composition in accordance with the UML
characterization, or if the aggregation is static or dynamic. For inheritance hierarchies, the additional information can specify if a specialization produced by the inheritance is permanent or temporal. If the specialization is permanent, then the corresponding conditions on the constant attributes must characterize the specialization relationship. On the other hand, if the specialization is temporary, then the condition based on variable attributes or the events that activate/deactivate the child role must be specified.
Some applications may require a large number of classes to fully specify. In this case, classes may be gathered into clusters. Clusters make it easier for the designer or system analyst to understand the application, one cluster at a time. Thus, clusters help reduce the complexity of the view of the object model.
DYNAMIC MODEL
The system class architecture is specified with the object model. Additional features, however, such as which object life cycles can be considered valid, and which inter-object communication can be established, also have to be input in the system specification. For this purpose, a dynamic model is provided.
The dynamic model specifies the behavior of an object in response to services, triggers and global transactions. In one embodiment, the dynamic model is represented by two diagrams, a state transition diagram and an object interaction diagram.
The state transition diagram (STD) is used to describe correct behavior by establishing valid object life cycles for every class. A valid life refers to an appropriate sequence of states that characterizes the correct behavior of the objects that belong to a specific class. Transitions represent valid changes of state. A transition has an action and, optionally, a control condition or guard. An action is composed of a service plus a subset of its valid agents defined in the Object Model. If all the agents are selected, the transition is labeled with an asterisk (*). Control conditions are well formed formulas defined on object attributes and/or service arguments to avoid the possible non-determinism for a given action. Actions might have one precondition that must be satisfied in order to accept its execution. A circle with an imbedded circle represents the state previous to existence of the object. Transitions that have this state as source must be composed of creation actions. Similarly, a bull's eye represent the state after destruction of the object.
Transitions having this state as destination must be composed of destruction actions.
Intermediate states are represented by circles labeled with an state name.
Accordingly, the state transition diagram shows a graphical representation of the various states of an object and transitions between the states. FIG. 4A illustrates an exemplary state transition diagram 400 in accordance with one embodiment of the present invention. States are depicted in the exemplary state transition diagram 400 by means of a circle labeled with the state name. Referring to FIG. 4A, the "bookO" state 404 is indicated by a circle with the name "bookO." Before an object comes into existence, a blank circle 402 is used to represent this "state" of nonexistence, which is the source of the initial transition 410 labeled by a corresponding creation action. A bull's eye 406 is used to represent the state after which an object has been destroyed, as by a transition 416 occasioned by the [*] :
_book action.
destroy Transitions are represented by solid arrows from a source state to a destination state. The middle of the transition arrow is labeled with a text displaying the action , precondition and guards (if proceeds). In the example, transition 412 is labeled with a loan book action associated with the transition 412 and a precondition `if state =
"available". Thus, the system will only accept the execution of the action if the state attribute of the book is "available." In other words, the Conceptual Model requires that a book can only be loaned if the book is available. "As another-example, transition 414 is labeled with a return_book action associated with the transition 414" and a precondition `if state - "lent"'. In other words, the Conceptual Model requires that a book can only be returned if the book has been lent.
The object interaction diagram specifies inter-object communication. Two basic interactions are defined: triggers, which are object services that are automatically activated when a pre-specified condition is satisfied, and global transactions, which are themselves services involving services of different objects and or other global transactions.. There is one state transition diagram for every class, but only one object interaction diagram for the whole Conceptual Model , where the previous interactions will be graphically specified.
In one embodiment, boxes labeled with an underlined name represent class objects. Trigger specifications follow this syntax: destination::action if trigger-condition.
The first component of the trigger is the destination, i.e., the object(s) to which the triggered service is addressed. The trigger destination can be the same object where the condition is satisfied (i.e. self), a specific object, or an entire class population if broadcasting the service. Finally, the triggered service and its corresponding triggering relationship are declared. Global Transactions are graphically specified by connecting the actions involved in the declared interaction. These actions are represented as solid lines linking the objects (boxes) that provide them.
Accordingly, communication between objects and activity rules are described in the object interaction diagram, which presents graphical boxes, graphical triggers, and graphical interactions. FIG. 4B illustrates an exemplary object interaction diagram 420 in accordance with one embodiment of the present invention.
In the object interaction diagram 420, the graphical interactions are represented by lines for the components of a graphical interaction. Graphical boxes, such as reader box 422, are declared, in this case, as special boxes that can reference objects (particular or generic) such as a reader. Graphical triggers are depicted using solid lines that have a text displaying the service to execute and the triggering condition.
Components of graphical interactions also use solid lines. Each one has a text displaying a number of the ~
interaction, and the action that will be executed. In the example, trigger 424 indicates that the reader punish action is to be invoke when the number of books that a reader is currently borrowing reaches 10.
FUNCTIONAL MODEL
Many conventional systems take a shortcut when providing a functional model, which limits the correctness of a functional specification.. Sometimes, the model used breaks the homogeneity of the object-oriented models, as happened with the initial versions of OMT, which proposed using the structured DFDs as a functional model. The use of DFD techniques in an object modeling context has been criticized for being imprecise, mainly because it offers a perspective of the system (the functional perspective), which differs from the other models (the object perspective).
Other methods leave the free-specification of the system operations in the hands of the designer, which leads to inconsistencies. .
One embodiment of the present invention, however, employs a functional model that is quite different with respect to these conventional approaches. In this functional model, the semantics associated with any change of an object state is captured as a consequence of an event occurrence. To do this, the following information is declaratively specified: how every event changes the object state depending on the arguments of the involved event, and the object's current state. This is called "valuation."
In particular, the functional model employs the concept of the categorization of valuations. Three types of valuations are defined: push-pop, state-independent and discrete-domain based. Each type fixes the pattern of information required to define its functionality.
Push pop valuations are those whose relevant events increase or decrease the value of the attribute by a given quantity, or reset the attribute to a certain value.
State-independent valuations give a new value to the attribute involved independently of the previous attribute's value.
Discrete-domain valuations give a value to the attributes from a limited domain based on the attribute's previous value. The different values of this domain model the valid situations that are possible for the attribute..
To illustrate these features, TABLE 2 shows a functional model for a "book number" attribute 344 of the reader class 340, in a Conceptual Model representing a typical library.
CLASS: Reader ATTRIBUTE: book number CATEGORY: push-pop loan( 1 Increase Returno Decrease These valuations are categorized as a push-pop because their relevant events increase or decrease the value of the book number attribute 344 by a given quantity (1).
In the example, its related event loan() has the increasing effect and return() has the decreasing effect.
This categorization of the valuations is a contribution of one aspect of the present invention that allows a complete formal specification to be generated in an automated way, completely capturing a event's functionality Accordingly, the functional model is responsible for capturing the semantics of every change of state for the attributes of a class. It has no graphical diagram. Textual information is collected through an interactive dialog that fills the corresponding part of the Information Structures explained before. FIG. 5 illustrates an exemplary dialog for receiving input for the functional model.
PRESENTATION MODEL
The Presentation Model is a set of pre-defined concepts that can be used to describe user interface requisites. These concepts arise from distilling and abstracting repetitive scenarios in developing the user interfaces. These abstractions of the repetitive scenarios are called patterns. A set of patterns is called a pattern language.
In this sense, the Presentation Model is a collection of patterns designed to reflect user interfaces requirements. A pattern is a clear description of a recurrent problem with a recurrent solution in a given restricted domain and giving an initial context. The documented patterns abstract the essence of the problem and the essence of the solution and therefore can be applied several times to resolve problems that match with the initial context and domain.The pattern language is composed of a plurality of patterns. The present invention is not limited to any particular list of patterns, but the following is a brief description of some user interface patterns that have been found to be useful:
Service Presentation Pattern, Instance Presentation Pattern, Class Population Presentation Pattern, Master-Detail Presentation Pattern and Action Selection Presentation Pattern.
A Service Presentation Pattern captures how a service will request data to the final user. This patterns controls the filling out of service arguments and contains actions to launch the service or to exit, performing no action. It is based on other lower level patterns that refer to more specific interface tasks such as an introduction pattern, defined selection pattern, population selection pattern, dependency pattern, status recovery pattern, supplementary information pattern, and argument grouping presentation:
The introduction pattern handles with restrictions to input data that must be provided to the system by the final user (i.e., the user who employs the final application). In particular, edit-masks and range-values are introduced, constraining the values that can validly be input in the interface. In this manner, the user-entry errors are reduced. This pattern can be applied to arguments in services or to attributes in classes to improve data input process through validating input arguments.
The defined selection pattern specifies a set of valid values for an argument. When the input data items are static, are a few, and are well known, the designer can declare by enumeration a set containing such valid values. This pattern is similar to those that define an enumerated type and an optional default value. Accordingly, the final user can only select an entry from the pre-specified set, thereby reducing error prone input. For example, one representation of this pattern could be a Combo-Box. This pattern can be applied to arguments in services or to attributes in classes to improve data input process.
The population selection pattern handles the display and selection of objects inform among a multiple objects. Specifically, this pattern contains a filter, a display set, and an order criterion, which respectively determine how objects are filtered (Filter Expression), what data is displayed (Display Set), and how objects are ordered (Order Criteria). This pattern may be thought of as a SQL Select statement with columns, where for the filter expression and order by for the ordering clauses, and can be applied to object-valuated arguments in services whenever it is possible to select an object from a given population of existing objects.
The dependency pattern is a set of Event-Condition-Action (ECA) rules allowing the specification of dependency rules between arguments in services.
When arguments are dependent on others, these constraints use this kind of rules.
The status recovery pattern is an implicitly created pattern that recovers data from object attributes to initialize service arguments. This can be modeled as an implicit set of dependency patterns. For example, to change the data associated of a Customer object, a form to launch the change service appears.
If the user provides the Customer OID (Object Identifier), the interfaces can use this OID to search the object and recover the data associated to the Customer, such as name, telephone, address, etc.
Ili The supplementary information pattern handles the feedback that is provided to final users in order to assure they choose or input the correct OID
(object identified) for an existent object. For example, to select a Customer, an OID must be provided. If the name of the Customer is automatically displayed as answer to an OID input, the user receives a valuable feedback data that assures the user in selecting or correcting the input data. The supplementary information pattern is applicable to object-valuated arguments."
The argument grouping presentation pattern captures how to group the requested service arguments according to the user wishes.
An Instance Presentation Pattern captures how the properties of an object are presented to the final user. In this context, the user will be able to launch services or to navigate to other related objects. The instance presentation pattern is a detailed view of an instance.
A Class Population Presentation Pattern captures how the properties of multiple objects of one class are presented to the final user. In this context, once an object is selected, the final user will be able to launch a service or to navigate to other related objects. The objects can also be filtered.
A Master-Detail Presentation Pattern captures how to present a certain object of a class with other related objects that may complete the full detail of the object. To build this pattern the following patterns are used: instance presentation, class population presentation and, recursively, master-detail presentation. In this manner, multi-detail (multiple details) and multi-level master-detail (multiple levels recursively) can be modeled. For example, one scenario involves an invoice header followed by a set of invoice lines related to the invoice.
An Action Selection Pattern captures how the services are offered to final users following the principle of gradual approach. This pattern allows, for example, generating menus of application using a tree structure. The final tree structure will be obtained from the set of services specified in the classes of the Conceptual Model. The user could launch services or queries (observations) defined in the Conceptual Model.
A Filter Expression is a well-formed formula that evaluates to a Boolean type.
This formula is interpreted as follows: the objects that satisfy the formula pass the filter, the ones that not fulfill the condition do not pass the filter. Consequently, the filter acts like a sift that only allows objects that fulfill the formula to pass. These formulas can contain parameters that are resolved at execution time, providing values for the variables or asking them directly to the final user. A filter pattern may be thought of as an abstraction of a SQL where clause, and is applied in a population selection pattern.
A Display Set is an ordered set of attributes that is shown to reflect the status of an object. A Display Set may be thought of as an abstraction of the columns in a SQL
clause, and is applied in a population selection pattern.
The Order Criteria is an ordered set of tuples that contain: an attribute and an order (ascending / descending). This set of tuples fixes an order criterion over the filtered objects. An order criterion pattern may be thought of as an abstraction of an order by SQL clause, and is applied in a population selection pattern.
FORMAL SPECIFICATION
The CASE tool 210, after presenting a user interface for capturing system requirements 200, converts the system requirements into a formal specification 215. In particular the CASE tool 210 builds upon the previously described models as a starting point and automatically generates a corresponding formal and object-oriented specification 215, which acts as a high-level system. repository. In a preferred embodiment, the formal language being employed is OASIS, version 2.2 by Oscar Pastor Lopez and Isidro Ramos Salavert, published October 1995 by the "Servicio de Publicaciones de la Universidad Politecnica de Valencia" (legal deposit number: V-1285-1995).
Conversion of captured system requirements 200 into a formal specification 215 is a main feature of one aspect of the invention: each piece of information introduced in the conceptual modeling step has a corresponding formal counterpart, which is represented as formal language concept. The graphical modeling environment associated with one embodiment of the invention may be thus viewed as an advanced graphical editor for formal specifications.
Therefore, an introductory presentation of the OASIS specification language is provided herein for a more detailed view of this embodiment of the present invention, TABLE 3 shows a formal specification 215 for the reader class that was automatically obtained from the Conceptual Model:
CONCEPTUAL SCHEMA library domains nat,bool,int,date,string class reader identification by_reader_code: (reader_code);
constant-attributes age : String ;
reader-code : String ;
name : String ;
variable attributes book count : Int private events new_reader O new;
destroy reader O destroy;
punishO;
shared events loan() with book;
return() with book;
constraints static book count < 10;
valuation [loan()) book-count= book-Count + 1;
[return O ] book _count= book-count - 1;
preconditions librarian:destroy_reader () if book-number = 0 triggers Self :: punish() if book count = 10;
process reader = librarian:newreader() readerO;
reader0= librarian:destroy_reader() +
loan () readerl;
readerl= if book count=1 return() readero + (if book count > 1 return() + if book count < 10loant)) readerl;
end class END CONCEPTUAL SCHEMA
The meaning of the different sections that integrate the formal description of the exemplary reader class specification is explained. A class in OASIS is made up of a class name "reader", an identification function for instances (objects) of the class, and a type or template that all the instances share.
The identification function by_reader code, characterizes the naming mechanism used by objects and yields a set of surrogates belonging to a predefined sort or to a sort defined by the user (the so-called domains in OASIS). These domains are imported in the class definition. The most usual are predefined as int, nat, real, bool, char, string and date.
They represent numbers, Boolean values, characters, strings and dates in a particular format. New domains can be introduced in a specification by defining the corresponding abstract data type.
A type is the template that collects all the properties (structure and behavior) which are shared by all the potential objects of the class being considered.
Syntactically, the type can be formalized as a signature, which contains sorts, functions, attributes and events to be used, a set of axioms, which are formulas in a dynamic logic, a process query as a set of equations with variables of a sort process that are solved in a given process algebra. When these variables are instantiated, we have the ground terms that represent possible lives of instances (objects).
A class signature contains a set of sorts with a partial order relation. Among this set of sorts is the sort of interest (the class name) associated with the class being defined.
A class signature also contains a set of functions including those functions included in the definition of the (predefined) sorts and the identification function whose sort is the ADT
(Abstract Data Type) for identities implicitly provided with a class specification. The identification function provides values of a given sort to identify objects in order to assure that any object of a given class has a unique identity. For specification purposes, an identification is introduced mechanism comprising a declaration of one or more key maps used as aliases for identifying objects. The key maps are similar to the candidate key notion of the relational model. From a given key value, these maps return an associated object identity. Key maps will be declared as (tuples of) constant attributes.
A class signature also contains a set of attributes (constant, variable, and derived), see constant-attributes and variable-attributes sections in TABLE 3. These attributes all have the sort of the class as domain, and the given sort associated to the attribute being considered as co-domain.
A set of events is also contained in the class signature (see private events and shared events in TABLE 3), with the sort of the class as the domain, plus any additional sort representing event information, and-with the sort of the class (sort of interest) as the co-domain. This so-called sort of interest can be seen as a sub-sort of a general sort process when objects are viewed as processes.
Each event occurrence is labeled by the agent that is allowed to activate it.
When dealing with this actor notion, if the agent x initiates event a is written x : a and called an action; x could be the environment or any object of a system class. In one embodiment, an event always is associated with an agent. When defining an event, the designer is therefore forced to state which agent will be able to activate it.
Consequently, a set A of actions may be defined and obtained from and attached to the initial set of events.
In this way, the notion of the set of object services can be represented as an interface that allows other objects to access the state. The object services can be events (server view) or actions (client view) depending on whether these services are offered or requested. Actions become services requested by an object, by which the object can consult or modify states of other objects (or its own state).
In OASIS, there are the following kinds of dynamic formulas (set of class axioms):
Evaluations are formulas of the form cp [a] p' whose semantics is given by defining a p function that, from a ground action a returns a function between possible worlds. In other words, being a possible world for an object any valid state, the p function determines which transitions between object states are valid after the execution of an action a. In the example, there are the following evaluations:
[loan()] book-count= book_count+l;
[returnl)] book count- book count-1;
Within this dynamic logic environment, the formula cp is evaluated in s e W, and cp' is evaluated in p(a), with p(a) being the world represented by the object state after the execution in s of the action considered.
Derivations are formulas of the type cp- cp'. They define derived attributes p' in terms of the given derivation condition (stated in (p). Derivations basically differ from the evaluation formulas in that this derived evaluation is done in a unique state.
Integrity constraints are formulas that must be satisfied in every world.
Static and dynamic integrity constraints may be distinguished. Static integrity constraints are those defined for every possible world. They must always hold. On the other hand, dynamic ', integrity constraints are those that relate different worlds. They require the use of a temporal logic, with the corresponding temporal logic operators.
Preconditions are formulas with the template -,y[a]false, where cp is a formula that must hold in the world previous to the execution of action a. Only in the worlds }
where cp holds, is a allowed to occur. If -,cp holds, the occurrence of a gives no state as successor. We have the following precondition in the reader specification:
book number = 0 [librarian:destroy_readerO) false;
or, in a more convenient way for specification purposes, we can write librarian:destroy reader() if book number = 0 Triggers are formulas of the form y[-,ajfalse, where -,a is the action negation.
This formula means that a does not occur, and what does occur is not specified. If cp holds and an action other than a occurs, then there is no successor state.
This forces a to occur or the system remains in a blocked state. For instance, using the appropriate dynamic formula where we include in the triggered service information about the destination (according to the trigger expressiveness presented when the object interaction diagram 420 was introduced), we will declare:
book count = 10 [Self::punish()1 false This trigger may be written in an equivalent but more conventional way for specification purposes as:
Self::punish() if book count = 10;
Thus, triggers are actions activated when the condition stated in q) holds.
The main difference between preconditions and triggers comes from the fact that in triggers there is an obligation to activate an action as soon as the given condition is satisfied. In this way triggers allow us to introduce internal activity in the Object Society that is being modeled.
In any of these dynamic formulas, cp, ap' are well-formed formulas in a first order logic that usually refer to a given system state characterized by the set of values attached to attributes of objects in the state or world considered.
In OASIS, an object is defined as an observable process. The process specification in a class allows us to specify object dynamics and determines the access relationship between the states of instances. Processes are constructed by using events as atomic _ actions. However, the designer also has the choice of grouping events in execution units, which are called transactions.
The molecular units that are the transactions have two main properties. First, they follow an all-or-nothing policy with respect to the execution of the involved events:
when a failure happens during a transaction execution, the resultant state will be the initial one. Second, they exhibit the non-observability of intermediate states.
We will finish this section introducing the process specification of the reader class in TABLE 4:
reader = librarian : new_reader O = reader 0 ;
reader_0 = librarian:destroy_reader() + loan() reader 1;
reader-1 = if book_count=1 return() = reader_0 + (if book count > 1 return( ) + if book count < 10 loan U) =reader_i;.
The execution of processes are represented by terms in a well-defined algebra of processes. Thus, possible object lives can be declared as terms whose elements are transactions and events. Every process can be rewritten to a term in a basic process algebra BPA_Ss, with the = (sequence) and + (alternative) process operations.
This provides an implementation of concurrence based on arbitrary interleaving.
~
After having presented Conceptual Model and the OASIS formal concepts associated with them in accordance with one embodiment of the present invention, the mappings will now be discussed that generate a textual system representation 215 (that is a specification in OASIS) taking as input the graphical information introduced in the Conceptual Model. This formal specification 215 has in fact been obtained using CASE
tool 210, and constitutes a solid system documentation to obtain a final software product which is compliant with the initial requirements, as represented in the source Conceptual Model.
According to the class template introduced in the previous section, the set of conceptual patterns and their corresponding OASIS representation.
The system classes are obtained from the object model. For each class, there are a set of constant, variable or derived attributes; a set of services, including private and shared events and local transactions; integrity constraints specified for the class; and derivation expressions corresponding to the derived attributes. For a complex class (those defined by using the provided aggregation and inheritance class operators), the object model also provides the particular characteristics specified for the corresponding complex aggregated or specialized class.
The information given by the object model basically specifies the system class framework, where the class signature is precisely declared. The dynamic model uses two kind of diagrams, the state transition diagram and the object interaction diagram. From the state transition diagram, the following are obtained: event preconditions, which are those formulas labeling the event transitions; the process definition of a class, where the template for valid object lives is fixed. From the object interaction diagram, two other features of an OASIS class specification are completed: trigger relationships and global transactions, which are those involving different objects.
Finally, the functional model yields the dynamic formulas related to evaluations, where the effect of events on attributes is specified.
Having thus clearly defined the set of relevant information that can be introduced in a Conceptual Model in accordance with an embodiment of the present invention, the formal specification 215 corresponding to the requirements 200 provides a precise system V
repository where the system description is completely captured, according to the OASIS
object-oriented model. This enables the implementation process (execution model) to be undertaken from a well-defined starting point, where the pieces of information involved are meaningful because they come from a finite catalogue of conceptual modeling patterns, which, furthermore, have a formal counterpart in OASIS.
Automatic software production of a complete, robust application from a Conceptual Model to an implementation language (such as a third generation languages like C, C++, or Java) requires the Conceptual Model to be both correct and complete. In this section, the terms "correct" and "complete" have the following meanings dependent on the specific needs for the automated software production process system as:
A Conceptual Model is "complete" when there is no missing information in the requirements specification. In other words, all the required properties of the Conceptual Model are defined and have a value.
A Conceptual Model is "correct" when the information introduced in the Conceptual Model is syntactically and semantically consistent and not ambiguous. In other words, all the properties defined in the Conceptual Model have a valid value.
Referring back to FIG. 2, the validator 220 receives as input the formal specification 215 of the Conceptual Model using an Object-Oriented Formal Specification Language (such as OASIS) as high level data repository. From a formal point of view, a validated OASIS specification 215 is correct and complete because the specification 215 is formally equivalent to a dynamic logic theory, using a well-defined declarative and operational semantics.
Formal specification languages benefit from the ability of formal environments to ensure that formal specifications 215 are valid or can be checked to be valid.
Formal languages define a grammar that rules language expressiveness.
Two procedures are used for Conceptual Model validation. For completeness, validation rules are implemented by directly checking the gathered data for the Conceptual Model, e.g., a class must have name, one attribute being its identifier and one service. For correctness, an extended formal specification language grammar is implemented in order to validate the syntax and meaning of all the formulas in the Conceptual Model.
Coiu cm ESs More specifically, for completeness, all the elements in a formal specification language have a set of properties that both have to exist and must have a valid value.
Most of the properties are strictly implemented to have a full definition and valid values.
However, the CASE tool 210 allows, for easy of use during a model inputting, to leave some properties incomplete or with invalid values. These properties will be checked by the validator 220 to be complete (and correct) prior to any automatic software production process.
The elements which are used to validate a Conceptual Model are described next.
For each element it is stated if validation will be strict (e.g. when all his properties have to exist and must have a valid value at creation time) or flexible (e.g validation will be accomplished at a later time). Some properties are optional, (e.g. that may not exist) but if they are defined, they must be validated. These elements are given in TABLE 5:
- Class o Name. Strict o ID function Flexible o Attributes (at least one) Flexible o Services (at least Create service). Flexible o Static and Dynamic Integrity Constraints (optional) ^ Their formula Strict - Attribute o Name. Strict o Type (Constant, Variable, Derived). Strict o Data-type (Real, integer, etc). Strict o Default Value. Strict o Size (if proceeds) Strict o Request in Creation service. Strict o Null value allowed. Strict o Evaluations (variable attributes). Flexible o Derivation formula (derived attributes). Flexible - Evaluation o One variable attribute of a class Strict o One service of the same class Strict o Condition (optional). Strict o Formula of evaluation. Strict - Derivation o Formula. Strict o Condition (optional). Strict - Service o Name. Strict o Arguments.
^ argument's name Strict ^ data-type Strict ^ default value (optional) Strict ^ null value Strict ^ size (if proceeds) Strict o For a transaction, its formula. Flexible - Preconditions of an action o Formula. Strict ^ Agents affected by condition Strict - Relationship: Aggregation o Related classes (component &composite) Strict o Relationship name. Strict o Both directions Role names. Strict o Cardinality. Strict o Inclusive or referential. Strict o Dynamic. Strict o Clause "Group By" (Optional). Strict o Insertion and deletion events (if proceed) Strict - Relationship: Inheritance o Related classes (parent & child) Strict o Temporal (versus permanent) Strict o Specialization condition or events Strict - Relationship: Agent o Agent class and service allowed to activate. Strict - State Transition Diagram (STD) o All states of class (3 at least). Flexible - State in STD
o Name. Strict - Transition in STD
o Estate of origin. Strict o Estate of destination. Strict o Service of class. Strict Control condition (optional). Strict Trigger o Condition. Strict o Class or instance of destination. Strict o Target (self, object, class) Strict o Activated service. Strict o Service arguments' initialization (Optional) ^ Arguments' values Strict Global Interactions o Name. Strict o Formula. Strict User exit functions o Name. Strict o Return data-type Strict o Arguments, (Optional) = Argument's name Strict ^ Argument's data-type Strict COMPLETENESS
Some properties of components in formal specification languages are "well formed formulas" that follow a well-defined syntax. It is therefore, a requirement to ensure that all introduced formulas in the Conceptual Model were both syntactical and semantically correct.
Not all formulas used in the Conceptual Model have the same purpose.
Therefore, there will be several types of formulas. Depending of formula's type, the use of certain operators and terms (operands, like: constants, class attributes, user-functions, etc.) are allowed. A process and a set of rules in grammar to validate every type of formula in the Conceptual Model also exist.
More specifically, the Conceptual Model includes formulas of the following types as shown in TABLE 6:
{
- Default Value Calculation of o Class Attributes (Constant and Variable) o Service and Transaction Arguments - Inheritance: Specialization condition - Static and Dynamic Integrity Constraints - Derivations and Valuations:
o Calculation formula (Derived or Variable attributes respectively) o Conditions (optional) - Preconditions for actions (Services or Transactions) - Control Conditions for transitions in State Transitions Diagram - Triggering conditions .
- Local and Global Transactions formulas These formulas are validated at the time they are introduced, by preventing the designer from leaving an interactive textual dialog if formula is not syntactically and semantically correct.
a syntactically correct; every class must have In general, every formula must be ery an identification function; every class must have a creation event; every triggering formula must be semantically correct (e.g. self triggers to an unrelated class are forbidden); and every name of an aggregation must be unique in the conceptual schema. If these =
conditions are not satisfied, then an error is raised.
A warning may be raised, on the other hand, if any of the following do not hold:
every class should have a destroy event; every derived attribute should have at least a derivation formula; every service should have an agent declared to execute it;
and every argument declared in a service should be used.
Validation process will also be invoked every time the designer performs a change into the model that may invalidate one or more formulas. As mentioned earlier, for ease of use, certain type of formulas are allowed to be incorrect, which the designer will have to review at a later time. The automatic software production process in accordance with one embodiment of the present invention, however, will not continue to code generation, if not all the formulas are correct. Each time the designer introduces a modification in the Conceptual Model specification, all affected formulas will be checked. As a result, the following cases may happen:
1. If any of the affected formulas makes reference to a "Strict" property, the change will be rejected. An error will be raised to inform the designer.
2. If none of the affected formulas reference a "Strict" property, a modification to the Conceptual Model will be accepted. An action-confirmation dialog is displayed before any action is taken..
3. If there is no affected formula, modification is performed straightaway. In order to validate the user interface information, the validator 220 checks the following for errors: the patterns defined must be well constructed with no essential information lacking; the attributes used in filters must be visible from the definition class; the attributes used in order criteria must be visible from the definition class;
the formula in a filter must be a well-formed formula using the terms defined in the model; the action selection pattern must use as final actions objects defined in the Conceptual Model; and the set of dependency patterns must be terminal and have confluence. Warnings may be generated under the following conditions: if a pattern is defined but not used (applied), or if an instance pattern is duplicated.
Automatic software production from Conceptual Models requires these Conceptual Models to be correct and complete. Applying the characteristics and properties of formal specification languages makes it possible to effectively validate a Conceptual Model. The validation process is based on the grammar defined by the formal specification language, and partial validation is to be invoked any time the designer introduces modifications to the Conceptual Model specification. Prior to any automatic software production process, Conceptual Model will be validated in a full validation as a pre-requisite.
TRANSLATION OVERVIEW
The validated formal specification 215 is the source for an execution model that handles the implementation-dependent features associated with a particular machine representation. To implement the specified system, the way in which users interact with system objects is predefined. In accordance with one embodiment, the execution template presented in FIG. 6 can be used to achieve this behavior. FIG. 6 is a flow diagram illustrating the high level view of the operation of translating a formal specification into a full application by following what it is referred to as "execution model"..
The process starts by logging the user into the system and identifying the user (step 600). An object system view is provided (step 602), determined by the set of object attributes and services that the user can see or activate. After the user is connected and has a clear object system view, the user can then activate any available service in the user's worldview. Among these services, there will be observations (object queries), local services, or transactions served by other objects.
Any service activation has two steps: build the message and execute message if possible. In order to build the message, the user has to provide information to identify the object server (step 604). The existence of the object server is an implicit condition for executing any service, except for the service new. Subsequently, the user introduces service arguments (step 606) of the service being activated (if necessary) to build the message.
Once the message is sent (step 608), the service execution is characterized by the occurrence of the following sequence of actions in the server object. The state transition is checked (step 610) for verifying that a valid transition exists in the fonnai specification for the selected service in the current object state. The preconditions are checked for their satisfaction (step 612) for indicating that the precondition associated to the service must hold. If either of these actions does not hold, an exception will arise and the message is ignored.
Otherwise, the process continues with fulfilling the validations (step 614) where the induced service modifications take place in the involved object state. To assure that the service execution leads the object to a valid state, the integrity constraints (step 616) are verified in the final state. If the constraint does not hold, an exception will arise and the previous change of state is ignored. After a valid change of state, the set of condition-action rules that represents the internal system activity is verified. If any of them hold, the specified service will be triggered (step 618).
Accordingly, the steps illustrated in FIG. 6 guide the implementation of any program to assure the functional equivalence between the object system specification collected in the Conceptual Model and its reification in an imperative programming environment.
In one embodiment of the present invention, several translators may be used to complement the CASE tool 210 to constitute an automatic software production system.
In one implementation, for example, the translators produce an application in accordance with a three-tiered architecture suitable, for example, for Internet applications.
Particularly, three different translators arise, corresponding to each tier: a system logic translator 232, a user-interface translator 234, and a database generator 236.
In addition, a fourth translator is used, documentation generator 238. These different translators are characterized by the output produced and, though potentially having the same input, each translator focuses on a particular subset of information in the above mentioned high level repository 215.
SYSTEM LOGIC TRANSLATION
The system logic translator 232 automatically generates code for a third generation programming language from information in the high level repository.
The output of the system logic translator 232 corresponds with the middle-tier in a three-tiered architecture.
In one embodiment, the system logic translator 232 produces source code that covers the following: (1) communications subsystem with the user interface functions, (2) access to and communication with the persistence layer, (3) standard query services for reading the persistence layer contents, and (4) error handling produced by the persistence layer and client communications..
The communications subsystem is configured for receiving requests from a client, invoking internal methods, and returning replies to requestors, that verify the requestor's existence and authorization to perform the requested service; verify the existence and validity of the requested server instance; create a copy of the requested server instance in memory accessing the persistence layer for persistent attributes or calculating the value of derived ones ; validate state transition for the requested service as specified in the state transition diagram 400 in the Conceptual Model; verify that the requested service's preconditions hold; perform all valuations related to the requested service as specified in the functional model; verify constraints for the new state achieved by the requested server instance; check trigger conditions to execute the corresponding actions; and make changes in the requested server instance persistent.
In addition, code is generated for access to and communication with the persistence layer, service standard queries to read persistence layer contents, and handle errors produced by the persistence layer and communications with client in one implementation for examples the generated code may include scripting to create and drop tables, constraints, and indexes to define a data model in a Relational Database System (RDBMS) in accordance with the validated spcification 215 of the Conceptual Model..
In one embodiment, the first phase of code generation is the retrieval of information from the Conceptual Model 215 and storage of this information in code generation structures in memory. Three kinds of elements guide the retrieval of information: classes, global transactions, and global functions. Relevant information to be obtained from classes in the Conceptual Model include: name, constant attributes (name, type, requested upon creation, and initialization value formula), variable attributes (name, type, requested upon creation, initialization value formula, and null values admittance), derived attributes (name, type, and derivation formula), identification function, events (name, arguments: name and type, and precondition formula), transactions (name, type, j arguments: name and type, precondition formula, and transaction formula), valuation formulae, state transitions (initial state, final state, service name, valid agents, and transition condition formula), static constraints formulae, dynamic constraints formulae, trigger conditions formulae, ancestor class (name), specialized classes (name, specialization condition formula, precondition redefinitions, and valuation redefinitions), aggregation relationships (related class, cardinalities, static or dynamic, and role names), and population selection patterns (filter: name and filter variables, order criteria).
Relevant information to be obtained from global interactions in the Conceptual Model includes: name, arguments (name and type), and global interaction formula.
Relevant information to be obtained from global functions in the Conceptual Model:
include: name, return type, and arguments (name and type).
Generated code follows a component-based structure, based on the main unit of information that is found in the Conceptual Model, that is: the class. Each class in the Conceptual Model yields, in a first approach, several of software components.
For example, one component, referred to as a "server component" has an interface comprising a method for each service present in the signature of the corresponding class.
Another component, whose interface comprises the methods necessary to query the population of the corresponding class, is called a "query component." A
particular kind of executive component is the component relating to global interactions defined in the {
Conceptual Model, whose interface consists of a method per global interaction.
These components constitute the two access points the second or middle tier offered to the first or presentation tier. Server components receive requests from the presentation tier that relate to the execution of services, and query components receive requests from the presentation tier that relate with querying the persistence tier. This is appropriate for Internet-deployed applications, because this allows for context-free, scalable, transactional solutions. Nevertheless these are not the only components generated.
Another generated component directly related to a class of the Conceptual Model is the one called "Executive Component" and is responsible for resolving or executing each of the services in the signature of the corresponding class. This component receives request from its corresponding server component or from other executive components.
Since a main purpose of the executive component is to resolve the services offered in the class signature, the interface presented by the executive component to the other components comprises a method per service. Each of these methods is structured according to the execution model in accordance with an embodiment of the invention.
In other words, the executive component is responsible for the following operations: verify the existence and validity for the requested server instance; create a copy of the requested server instance in memory accessing the persistence layer (by means of the above mentioned corresponding query component) to retrieve the values of constant and variable attributes; validate state transition for the requested service and the present state of the requested server instance as specified in the corresponding state transition diagram in the Conceptual Model; verify the satisfaction of the requested service preconditions; modify the value of the instance variable attributes by performing all valuations affected by the service as specified in the functional model of the Conceptual Model, thus changing the state of the requested server instance;
validate the new state achieved by the requested server instance by verifying its static and dynamic restrictions; check trigger conditions to determine which actions should be triggered if needed; communicate with the persistence layer for all persistent attributes of the requested server instance. Additionally, if the class is an agent of any service, another method is added to the interface whose purpose is that of validating the requestor's existence.
Another kind of executive component is a component related to global interactions defined in the Conceptual Model, whose interface consists of a method per global interaction.
If the class belongs to an inheritance hierarchy, all executive components of the same hierarchy are grouped into a single, special executive component.
Nevertheless there would still be one server component per class in the hierarchy.
Another component to which a class in the Conceptual Model gives rise is a component called the "T component". This component is used to store a copy of the constant and variable attributes of an instance of the corresponding class, as well as the methods to calculate the value of its derived attributes. The corresponding query component implements a collection whose items are T components.
Another component to which a class in the Conceptual Model may give rise is a component called "P component". This component is used to store in memory the values needed to initialize the constant and variable attributes of the corresponding class when creating an instance of it, or just the values of the attributes that constitute the class identification mechanism. Such a component appears whenever the corresponding class is a multi-valued component of an aggregation relationship.
Another component to which a class in the Conceptual Model may give rise is a component called "PL component". This component implements a collection whose items are P components, as well as the methods needed to add and get items from the collection, and get the number of items in the collection. Such a component appears whenever the corresponding class is a multi-valued component of an aggregation relationship.
Another component to which a class in the Conceptual Model may give rise is a component called "C Components". This component is used to store in memory the values needed to initialize the constant and variable attributes of the corresponding class it when creating an instance of it. Such a component appears whenever the corresponding class is a temporal or permanent, condition-based, specialization.
Additional components includes a CC component, an error component, a trigger component, a trigger list component, an instance list component, and condition, disjunction, and conjunction components.
The CC component appears whenever there is, at least one temporal or permanent, condition-based, specialization in the Conceptual Model. The CC
component implements a collection whose items are C components, a pair of methods to add and get items to the collection (one pair per C component generated), and a method to get the number of items in the collection.
The error component always appears and is used to store information about the success or failure of a service execution. The trigger component stores information about a satisfied trigger condition so that the corresponding action can be later executed. The trigger list component implements a collection whose items are trigger components, as well as the methods to add an item to the collection, get any item from the collection, get the first item and get the number of items in the collection.
The instance list component implements a collection whose items are executive components playing in the execution of a given service. In addition to methods used to add an item to the collection, get an item, and get the number of items in the collection, this component implements a method to empty the collection and another one to look for aninstance by its identification function.
The condition, disjunction and conjunction Components are always generated and support the construction of complex boolean expressions, used to query the persistence layer, structured as a conjunction of disjunctions. The condition component stores information about a simple boolean condition, that is: two operands and an operator (+, -, o, <, <=, >_, > ...). The disjunction component implements a collection whose items are condition components (that is, a disjunction of conditions), as well as methods to add and get a condition from the collection and a method to get the number of conditions in the collection. The conjunction component implements a collection whose items are disjunction components (that is, a conjunction of disjunction), as well as methods to add and get a disjunction from the collection and a method to get the number of disjunctions in the collection.
In addition, two modules are also generated: a global module for grouping attributes and methods shared through the generated code, and a global functions module that groups the code of all global functions defined in the Conceptual Model.
TRANSLATION STRATEGY AND ARCHITECTURE
In accordance with one embodiment, code generation is driven by the information retrieved from the high level repository 215. The translation process can be divided into four phases: validation of the Conceptual Model (performed by validator 220), translation of the corresponding data model into a relational database management system (performed by database generator 236), retrieval of information from the Conceptual Model and storage of this information in memory structures and finally, generation of files from the information stored in memory (e.g. reading the information in memory structures to generate code in the target programming language).
Validation of the Conceptual Model is mandatory, while data model translation is optional, but both can be considered as prerequisites to the other two phases which are the ones strictly related to code generation. Translation structures are designed to store input information from the Conceptual Model and all have a method that uses this information to generate. source code in the target programming language.
These translation structures include: a class to store information needed to generate server components (server class), a class to store information needed to generate server components for global interactions (global interactions server class), a class to store information needed to generate executive components (analysis class), a class to it store information needed to generate executive components for global interactions (global interactions analysis class), a class to store information needed to generate executive components for inheritance hierarchies (inheritance hierarchy analysis class), a class to store information needed to generate query components (query class), a class to store information needed to generate T components (T class), a class to store information needed to generate C components (C class), a class to store information needed to generate CC component (CC class), a class to store information needed to generate P
components (P class), a class to store information needed to generate PL
components (PL
class), a class to store information on the arguments for every service of every class in the Conceptual Model (arguments list class), a class to store information on the identification function of every class in the Conceptual Model (analysis class list class), classes to generate the methods needed to resolve a service in executive components (event class, shared event class, transaction class, interaction class), classes to generate the auxiliary methods needed to resolve a service in both executive components and executive components for inheritance hierarchies (precondition class, static constraints class, dynamic constraints class, ...etc.). classes to generate methods needed in query and T
components (T & Q method classes), a class to generate inheritance-specific methods (inheritance method class), and a class to monitor the generation process (code generation class).
The code generation class is responsible for retrieving all the information needed to generate code and for doing so in the appropriate order, for writing to files the generated code and organizing it into files properly according to the component-based structure. The code generation class maintains lists of the above mentioned generation structures in memory in which information retrieved from the Conceptual Model is to be stored and it later loops through these lists to write the appropriate files.
The information retrieval process basically comprises a series of loops through the classes in the Conceptual Model to gather all information needed, a loop trough global interactions and a loop through global functions in the Conceptual Model.
The last phase in the code generation process covers writing to files according to the component-based structure presented herein. This process comprises:
looping through the lists of instances above described that maintain the information needed to generate components and their attributes and methods, and call each element's code generation method; generating global interactions executive component;
generating global interactions server component; generating global functions module; and generating standard components.
For each global function a method is generated. The method has the same name as the global function and a translated return type. Each argument of the method has the same name of the corresponding argument of the global function and a translated type.
USER-INTERFACE TRANSLATION
In one embodiment, where the user-interface translator 234 automatically generates source code for a high order programming language such as Visual BASIC or JAVA from information in the high level repository. However, code may be generated in any computed language. Its output corresponds with the presentation tier in a three-tiered architecture. Thus, the user-interface translator 234 provides as output the source code of a component that implements the user interface functionality. This component is automatically generated without human intervention. The user-interface translator 234 uses as input data a validated Conceptual Model 215 and offers as output data, source code in a third generation language that implements an equivalent functional prototype related to the Conceptual Model the component is derived from.
In one embodiment of the present invention, the user-interface translator 234 produces source code to perform the following: a communications subsystem able to send {
requests to a business component, and receive replies; a logon to system for user authentication; and a menu of available services for specific authenticated user. For each available service, frame, screen or data collection dialog of all service arguments, the user-interface translator 234 generates code that sets initial values for arguments, validates introduced data (type, range, object existence, etc.), and calling to server activation. In addition, the user-interface translator 234 generates code for standard query services that list all instances status in a class and error handling.
Additionally, code is generated for a wider and flexible user-interface operation.
In a query service frame, form or screen, the following functionality will be available when a certain instance has been selected: navigation through relationships with related selected object. This navigation is used to browse among related data items following its related links; thus, the resultant code is suitable for Internet applications.
Additional functionality includes services activation for selected object; advanced query services including: filters (population selection), views (status selection), and sorting criteria; and context keeping for filling-in known services arguments. Context keeping is a user-facility. Context is data associated to the working user environment. This data is useful to provide default values for service arguments.
For its input, the user-interface translator 234 reads specification 215 of a Conceptual Model and stores this kind of information in intermediate structures in memory. The user-interface translator 234 is independent of the input medium in which III
the Conceptual Model is provided. In this way, the intermediate structures can be loaded from different data sources. The model is iterated in several passes to extract the relevant information in each phase of the translation process from the formal specification, including information about classes, aggregation relationships, inheritance relationships, agent relationships, global interactions, user defined functions, and interface patterns.
Translated applications are composed by forms that contain the user-interface offered to final user. A form, in abstract sense, is the interaction unit with the final user.
Forms are translated depending on capabilities of the target environment to match the requirements: e.g. windows dialogues for Windows environments, HTML pages in Web platforms, applets in Jav, etc.
Translated applications supply the user connection to the system. The user connection is resolved using an access form to authenticate the agent. In addition, the translated application provides a system user view. A user must be able to access services the user can launch. The main form is designed to accomplish this task.
For each service that can be executed by a user, the translated application generates an activation service form. For each class, the translated application generates a query / selection form. This form allows users to query data instances, search instances that fulfill a given condition, observe related instances and know which services can be launched for a given object in its current state. For each service, the translated application furnishes initialization values for object-valued arguments.
Initial data is also provided by managing information obtained from the browse made by the user.
The user encounters different scenarios interacting with the application.
These scenarios lead to define different types of forms. In the next section, each kind of form will be described.
In the Conceptual Model 215, some classes are defined as agents of services classes (called agent classes). That is, if an object is a service agent it is allowed to request the service. Each agent object must be validated authenticated before trying to request services. The Access Form requests an agent class (selected from a list of valid agents classes), an object identifier and a password. The data collected is used to verify if there exists a valid agent object that is allowed to access the system.
The Application Main Form contains a menu, where user can view the services he is allowed to execute. The source code associated to each action realized by user is automatically generated.
ii For each accessible service for at least one agent, a Service Form is generated.
These forms have an introduction field for each argument the user must provide. This argument's fields have attached code to validate data types, sizes, value-ranges, nulls, etc. Object-valuated fields provide facilities to search the object browsing information and filtering it. Code is generated to accomplish this task.
Each service argument can take its initial value in three different ways:
1. By Initial values. In the Conceptual Model, the designer can provide default values for attributes and arguments. If such value exists, code must be generated to supply the value.
2. By Context. Context information (for example, a list of recently observed objects) is useful to suggest values to object-valuated arguments that have the same type that collected ones. A function is generated to search appropriate values in the recently visited objects list.
3. By Dependency Pattern. In the Conceptual Model, the system designer can define Dependency Patterns. The Status Recovery pattern is an implicit set of dependency patterns too. In both cases, the change on an argument, can affect to values in another ones. So, certain argument values can be initially fixed in this way.
Data Validation can occur just after data input, interactively warning the user and just before sending data to system-logic. Object-valuated arguments validation requires {
checking object existence. To support validation, a function is generated for each service argument. The function is invoked before sending a request to system-logic.
When the user requests service execution, the service arguments are validated.
If the service arguments are valid, system logic is invoked to accomplish the service. The message built to invoke the system-logic uses the formal order to sort the arguments.
After executing the service, the user is informed whether the service succeeded or not.
This transactional approach is ideal for Internet applications. Accordingly, code to validate arguments and Code to invoke the system-logic with necessary arguments in the formal order are generated. Furthermore, possible errors are returned to inform the user.
The Query/Selection Form permits the querying of objects (that can be restrained -by filters) and the selection of an object. When an object is selected, the user can browse to other data items related to the object. In the same way, the user can launch a service of the selected object.
These query/selection forms include graphic items representing filters. A
visual component is used to filter the population of a class. Filters may contain variables. In such cases, fields for the variables are requested to users in order to form the condition of the filter.. For example: Find cars by color, by type and model.
These query/selection forms also include a visual component to show objects.
Inside this component objects that fulfill the filter condition (or every class population if filters are not defined) appear. The attributes displayed in the component are set by a Display Set.
These query/selection forms also include a visual component to launch services.
For example: given a car, the user can launch services in order to rent the car, return, or sell it. This task is achieved by a function that determines which service to launch of what object The corresponding Service Form is invoked for each exposed service. These query/selection forms also include a component to initiate the browsing. For example:
given a car, the user can view the driver, the driver's sons, etc. When the user navigates (follows a link from an object) a new query/selection form is displayed. In the same way that the previous component, there exists code to invoke the next form to display when user browses objects. When a query/selection form is reached by navigation, the form receives information about the previous object in order to display only the data related to that initial object.
In the applications, visited objects and navigation paths followed by users are stored. This information is named Context Information. When the user browses data between query/selection forms, the path followed is stored. Finally, when the user tries to invoke a service and a service form is needed, the application can provide, as an extra input to the service form, this contextual information. Then, the Service Form uses this data to provide initial values for object-valuated arguments.
USER-INTERFACE TRANSLATOR ARCHITECTURE
Using the Conceptual Model 215 used as input, the user-interface translator can retrieve information from memory structures, a relational database, using a query API
or any other input source. An intermediate structure in memory is filled with the Conceptual Model data relevant for translating the user-interface component.
Intermediate structure follows an architecture to the one defined in the Conceptual Model schema in which can be queried for classes, services, and attributes for a specific Conceptual Model.
When data is loaded in the intermediate structure, the real translation phase begins. Inside the source code files of the generated application, two types of files can be distinguished. One type of files is a set of files having fixed contains.
These files correspond to structures or auxiliary functions widely used that are always produced in the same way. These files are generated by dumping byte streams directly from the translator to final files in order to create them. Other files strongly depend from the Conceptual Model that is being processed. Therefore, although these files have a well-defined structure (detailed in the previous section), they have variable parts depending on the processed model. The user-interface translator 234 iterates the Conceptual Model to extract the relevant data to generate these variable parts.
The translation process for the user-interface translator 234 has the following tasks:
1. Generate the fixed files, e.g. headers, definitions, constants, and auxiliary functions to its respective files.
2. Generate auxiliary widgets (controls or Java Beans) depending on the application 3. For each class, generate a query / selection form, an instance selection component, a specialization component (if class is specialized from other class an requires extra initialization). For each service class, also generate a service form.
4. Generate an access form (identification).
5. Generate a main form containing the menu application.
6. Generate communication functions to reach system-logic server. These functions encapsulate the invocation of services available in the prototypes.
The Access Form is a little dialog box containing: a list of agent classes (from this list, the user chooses one), a field where the user provides OID for a valid object instance belonging to the previously selected class and a field for password. This form is mostly generated in a fixed way. The only varying section for each model is the mentioned agent classes list. By iterating over the model classes list and by checking which classes are agents such agent classes list can be obtained.
In order to provide access to the application's functionality, the services are arranged in an access-hierarchy to be converted to menu bars (Visual Basic client), HM
pages (Web client) or any other structure that allows browsing. By default, the hierarchy is built by iterating the classes and services in the Conceptual Model. The hierarchy can bee seen as an access tree to the application. For each class a tree item is built labeled with class alias. For each built-in item this mode has the following items as descendents:
an item labeled as `Query' to access a query form; an item for each service defined in the current class labeled with the service alias; and, in the case of inheritance relationship with other classes, an item is built for each direct subclass labeled with subclass alias.
Recursively, the same algorithm is applied until the inheritance tree is fully explored.
A Service Form requires the following input data extracted from the Conceptual Model: Service to generate, service class, arguments list, interface patterns linked to arguments. For each service, a form is generated that contains a graphic part and a functional part. The graphic part includes a widget attached to each argument that needs to be asked to user and a pair of widgets to accept or cancel the service launch. The functional part includes code to implement the event-drivers for the previous widgets, to initialize the properties of theses widgets with default values, to validate introduced values, and to invoke the service in the system-logic component.
A detailed explanation of how to generate a Service Form follows. First, two argument lists are obtained. The first one corresponds to the arguments defined in the ICI
service declaration (FL, Formal List). In this list the arguments are sorted by its formal declaration order. The second one contains the same arguments sorted by the presentation order (PL, Presentation List). Both orders are specified in the Conceptual Model.
Iterating through the formal List and for each argument: create a widget for each argument that has to be requested to user and set relevant properties to arguments like:
type, size, can be null, Introduction Pattern, Defined Selection Pattern or Population Selection Pattern Widgets are added for OK and Cancel commands, and graphic positions of widgets are arranged so they do not overlap. In one implementation, the form is divided in a logical grid of n columns by n rows and assign positions from left to right and from top to bottom to conveniently arrange the widgets. The logical positions are translated to physical position in the target language and rearrange action commands in the bottom-right comer of the form. Finally, the form is resized to adjust the size of data contained therein.
For output, the standard header of a form is dumped to a file. This step is dependent of the target language selected. Then, the graphic part of form is dumped to the file, including the definition of basic form properties, the definition of each widget., and the widgets' actions.
Finally, the source code attached to this form is translated and dumped. This process includes translating generic functions to manage events in the form, such as open and close events and produce code to assign and free resources. Also, functions to handle the Status Recovery Pattern and dependencies between widgets are translated.
Depending on the Status Recovery Pattern attached to the service, and possible Dependency Patterns defined in the service, code for changing argument values must be generated and the code that triggers such dependencies. The validation code is also translated too.
There are validation methods to check the values gathered in the widgets are right.
Finally, a function to translate service calling into invocation to system-logic services is generated.
The function built contains: a reference to system-logic object where the service is going to be executed; the invocation to a method that implements the service in the system-logic; and the arguments necessary to such function, constructed from values supplied form user through widgets.
In order to generate a query/selection form, the following Conceptual Model information is required: a class and its properties (alias), and the list of the Population Selection interface patterns defined for the class. Each pattern contains: a display set, a filter, and a sort criterion. In case there is no visualization set defined, the list of attributes belonging to the class is assumed. If a class lacks a population selection pattern, the following default values will be assumed: every attribute defined in the class is considered as part of the display set, and neither a filter (in this case the whole population of the class is returned) nor a sort criteria are attached.
Generating a query/selection form also requires information about the relationships of the class. For every class, a form is generated based on this information and contains a tabular representation of the display sets of the class, a set of grouped filters that allow to restrict search through the population, and a pop-up menu including navigability links to the classes related to the first one and available services to be launched over instances of the class.
The generated software component, which has been described before, provides the user-interface client functionality that includes all the required functionality for both validating and executing a prototype compliant to the Conceptual Model it has been derived from. The applications of the component are: prototyping, user validation of the Conceptual Model before capturing new requirements; testing to validate the Conceptual Model by analysts to verify that the model faithfully reflects the requirements; and ultimate application production, once the process of requirements capture is completed, the generated component can be considered as a final version implementing a functionally complete and ergonomic user interface. The component can be edited to customize the application to users desires with very little effort.
DATA MODEL TRANSLATION
In one embodiment, the database generator 236 automatically defines a data model in a Relational Database Management System (RDBMS) according to the validated specification in the high level repository 215. However, other forms of persistent storage may be used. Such as flat files, serialized files or Object Oriented databases. The output of the database generator 236 output corresponds with the persistence tier in a multi-tiered architecture. .
From the information in the high level repository about a given Conceptual Model, scripts are generated in order to create and delete tables, constraints (primary and foreign keys) and indexes. Scripts can optionally be executed in a Relational Database Management System to effectively create said data model.
From the point of view of relational databases, data is stored in tables with relationships between them. However, from the object oriented programming point of view, data is stored in object hierarchies.
Although the automatic software production system in accordance with one embodiment of the present invention is based on an object oriented methodology, it is necessary to find a physical data storage system to permanently store data managed by generated applications. Relational databases are preferred, because they are the industry-standard way to store data and, consequently, use of tables instead of objects as it would be desirable. Nevertheless, many object-oriented applications, like those produced by in accordance with an embodiment of the present invention, can be compatible with the Relational Model, since the static aspects of objects can be stored in tables following a translation process.
The generated data model comprises a set of tables and the corresponding relationships, as well as constraints on primary and foreign keys and indexes.
The generated data model reflects system data with the attributes defined in the classes specification and other class instances properties like their state, role if they are agents.
Information, gathered from the high level repository 215 and needed to produce the corresponding data model, focuses on classes and include the name, constant attributes (either emergent or inherited); variable Attributes (either emergent or inherited); identification function; inherited identification function;
aggregation relationships (either emergent or inherited); and agent information.
Preferably, the generated scripts follow a standard: ANSI SQL 92. This fact means that the generated data model can fit any database management system based on ANSI SQL 92, particularly most well known relational database management systems.
The process to obtain the data model follows these steps: For each elemental class of the Conceptual Model, a table in the selected relational database is created. For each constant or variable attribute in the class specification, a field in the table corresponding to the class is created. The field data type depends on Conceptual Model attribute data type translated into the target relational database. Derived attributes are not stored in the database since their value will be calculated upon request by special methods in the server code generated.
Primary keys are determined by attributes marked in the Conceptual Model as being identification attributes. Thus table fields corresponding to these attributes will constitute the primary key of the table. As a particular case, tables corresponding to specialized classes, in addition to fields representing emergent attributes, have fields that correspond to attributes that constitute the primary key of the table representing their ancestor class. If a specialized class does not have an identification function of its own, these fields, copied from the ancestor class, constitute the specialized table primary key.
At the same time, they constitute the foreign key to the parent class table.
On the other hand, if a specialized class has its own identification function, these fields only constitute a foreign key to the parent class table.
Aggregation case is more complicated, because aggregation has more dimensions.
The aggregation relationship dimensions determine its cardinalities that in turn determine representation in the database: If the relationship is multi-valued (maximum cardinality set to M) in both senses a new table is added in order to represent this aggregation relationship. This table has a field for each one that constitutes the primary key of related tables. The set of all this fields constitutes the primary key and, individually, fields coming from each related table's primary key, constitute foreign keys to each related table.
If the relationship is uni-valued (maximum cardinality set to 1) in one sense, the class related with only one instance of the other one copies the fields of the primary of the other one. These fields constitute a foreign key to the related class table.
If the relationship is uni-valued in both senses, any of the tables could have the foreign key to the other. The adopted option in this case is that the aggregate class have the reference to the component class. With respect to minimum cardinalities, if minimum cardinality is 0 then the corresponding field will take null values. Otherwise it will not. If identification dependence exists between two classes then fields of the primary key of the non-dependent class are copied to the table corresponding to the dependent class. They
Claims (30)
1. A process for using a computer having a memory for automatically generating a computer program from a validated Formal Specification that defines the desired structure and behavior of said computer program and its user interface, said Formal Specification written in a formal language and expressing the concepts in a Conceptual Model of said computer program created by an analyst entering requirements data defining the desired structure and behavior of said computer program, comprising:
A) articulating instances of code generation structures called translation structures stored in said memory by retrieving requirements data from a high level repository storing the validated Formal Specification generated from said Conceptual Model and storing the retrieved requirements data in said code generation structures so as to create a translation structure or code generation structure articulated with appropriate requirements data for every element of said Formal Specification, said translation structures comprising code generation structures which contain methods to generate source code components which are building blocks needed to write the source code of said computer program, said translation structures or code generation structures in memory taking the form of class data structures which store requirements data extracted from said Formal Specification and which include one or more code generation methods to generate source code components which have been articulated with said requirements data, said code generation structures comprising all translation structures needed to generate source code for said computer program which, when compiled and executed by a computer controls said computer to have the structure and behavior defined in said validated Formal Specification;
B) executing one or more methods in a code generation class which is one of said translations structures stored in memory to call the code generation methods of said translation structures in an order needed to generate source code components articulated with said requirements data, and generating a global interactions executive component, and generating a global interactions server component, and generating a global functions component, and generating standard components, and writing said source code components to files which comprise said computer program to be automatically written.
A) articulating instances of code generation structures called translation structures stored in said memory by retrieving requirements data from a high level repository storing the validated Formal Specification generated from said Conceptual Model and storing the retrieved requirements data in said code generation structures so as to create a translation structure or code generation structure articulated with appropriate requirements data for every element of said Formal Specification, said translation structures comprising code generation structures which contain methods to generate source code components which are building blocks needed to write the source code of said computer program, said translation structures or code generation structures in memory taking the form of class data structures which store requirements data extracted from said Formal Specification and which include one or more code generation methods to generate source code components which have been articulated with said requirements data, said code generation structures comprising all translation structures needed to generate source code for said computer program which, when compiled and executed by a computer controls said computer to have the structure and behavior defined in said validated Formal Specification;
B) executing one or more methods in a code generation class which is one of said translations structures stored in memory to call the code generation methods of said translation structures in an order needed to generate source code components articulated with said requirements data, and generating a global interactions executive component, and generating a global interactions server component, and generating a global functions component, and generating standard components, and writing said source code components to files which comprise said computer program to be automatically written.
2. The process of claim 1 wherein said translation structures comprise all the translation structures needed to write source code which, when compiled and executed by a computer, cause said computer to perform the following functions in accordance with an execution model:
provide a dialog by which a user can log in and identify himself or herself;
provide an object system view to the user who logged in which displays only the set of object attributes the logged in user can see and only the services the user who logged in can see or activate;
display a dialog by which the user who logged in can provide information to identify the object server which is to carry out a service and introduce service arguments of the service being activated and to build a service activation message containing said arguments and send said service activation message to said object server which is to execute said service;
control said object server to check any state transition which will be caused by execution of said service is a valid state transition as defined in said Formal Specification;
control said object server to check for satisfaction of any preconditions specified in said Formal Specification, and if either a precondition is not satisfied or the state transition which would be caused by execution of said service is not valid, ignore said service activation message;
control said object server to carry out the service if the state transition it will cause is valid and its preconditions are satisfied by making all valuation calculations required by said service and changing the values of attributes upon which said service acts;
control said object server to check integrity constraints to ensure said change of state of said object caused by said service carried out in step A6 does not violate an integrity constraint, and, if an integrity constraint is violated, the change of state caused by the execution of the service of step A6 is reversed to change the state of said system back to what it was before execution of said service;
control said object server to check condition-action rules specifying triggers to determine if any trigger conditions have been satisfied, and, if so, causing the service specified in said condition-action rule to be executed;
provide a dialog by which a user can log in and identify himself or herself;
provide an object system view to the user who logged in which displays only the set of object attributes the logged in user can see and only the services the user who logged in can see or activate;
display a dialog by which the user who logged in can provide information to identify the object server which is to carry out a service and introduce service arguments of the service being activated and to build a service activation message containing said arguments and send said service activation message to said object server which is to execute said service;
control said object server to check any state transition which will be caused by execution of said service is a valid state transition as defined in said Formal Specification;
control said object server to check for satisfaction of any preconditions specified in said Formal Specification, and if either a precondition is not satisfied or the state transition which would be caused by execution of said service is not valid, ignore said service activation message;
control said object server to carry out the service if the state transition it will cause is valid and its preconditions are satisfied by making all valuation calculations required by said service and changing the values of attributes upon which said service acts;
control said object server to check integrity constraints to ensure said change of state of said object caused by said service carried out in step A6 does not violate an integrity constraint, and, if an integrity constraint is violated, the change of state caused by the execution of the service of step A6 is reversed to change the state of said system back to what it was before execution of said service;
control said object server to check condition-action rules specifying triggers to determine if any trigger conditions have been satisfied, and, if so, causing the service specified in said condition-action rule to be executed;
3. The process of claim 1 wherein said translation structures or code generation structures comprise the following objects stored in memory of a computer:
a server class to store information needed to generate server components;
a global interactions server class to store information needed to generate server components for global interactions;
an analysis class to store information needed to generate executive components;
a global interactions analysis class to store information needed to generate executive components for global interactions in the form of names of global interactions, global transactions formulas and a list of arguments;
an inheritance hierarchy analysis class to store information needed to generate executive components for inheritance hierarchies;
a query class to store information needed to generate query components;
a T class to store information needed to generate T components;
a C class to store information needed to generate C components;
a CC class to store information needed to generate CC component;
a P class to store information needed to generate P components;
a PL class to store information needed to generate PL components;
an arguments list class to store information on the arguments for every service of every class in said Conceptual Model;
an analysis class list class to store information on the identification function of every class in the Conceptual Model;
one or more classes to generate the methods needed to resolve a service in executive components to implement events, shared events, transactions and object interactions (hereafter referred to as events classes);
one or more classes to generate the auxiliary methods needed to resolve a service in both executive components and executive components for inheritance hierarchies to implement at least precondition classes, static constraint classes, dynamic constraint classes if preconditions, static constraints and dynamic constraints are present in said Conceptual Model (hereafter referred to as auxiliary methods classes);
T & Q method classes to generate methods needed in query and T
components;
an inheritance method class to generate inheritance-specific methods; and a code generation class to control and implement a code generation process.
a server class to store information needed to generate server components;
a global interactions server class to store information needed to generate server components for global interactions;
an analysis class to store information needed to generate executive components;
a global interactions analysis class to store information needed to generate executive components for global interactions in the form of names of global interactions, global transactions formulas and a list of arguments;
an inheritance hierarchy analysis class to store information needed to generate executive components for inheritance hierarchies;
a query class to store information needed to generate query components;
a T class to store information needed to generate T components;
a C class to store information needed to generate C components;
a CC class to store information needed to generate CC component;
a P class to store information needed to generate P components;
a PL class to store information needed to generate PL components;
an arguments list class to store information on the arguments for every service of every class in said Conceptual Model;
an analysis class list class to store information on the identification function of every class in the Conceptual Model;
one or more classes to generate the methods needed to resolve a service in executive components to implement events, shared events, transactions and object interactions (hereafter referred to as events classes);
one or more classes to generate the auxiliary methods needed to resolve a service in both executive components and executive components for inheritance hierarchies to implement at least precondition classes, static constraint classes, dynamic constraint classes if preconditions, static constraints and dynamic constraints are present in said Conceptual Model (hereafter referred to as auxiliary methods classes);
T & Q method classes to generate methods needed in query and T
components;
an inheritance method class to generate inheritance-specific methods; and a code generation class to control and implement a code generation process.
4. The process of claim 3 wherein step A comprises retrieving information from classes, global transactions and global functions defined in said Conceptual Model and said Formal Specification to articulate said translation structures or code generation structures Specification, and wherein the step of retrieving information from classes further comprises the steps of retrieving the following information from each class defined in said Formal Specification and using it to populate the appropriate data fields in the appropriate translation structure class:
name;
constant attributes;
variable attributes;
derived attributes;
identification function;
events including the name, arguments for said event including name and type, and precondition formulae;
transactions including, for each said transaction, the name, type, precondition formulae, and transaction formula and arguments including, for each argument, the name and type;
valuation formulae;
state transitions including an initial state, final state, service name, valid agents, and transition condition formula;
static constraints formulae;
dynamic constraints formulae;
trigger conditions formulae;
ancestor class name;
specialized classes including the name, specialization condition formula, precondition redefinitions, and valuation redefinitions;
aggregation relationships including related class, cardinalities, static or dynamic, and role names; and population selection patterns including any filter including any name and filter variables, and/or order criteria specified for said filter;
and wherein said step of retrieving information from global interactions defined in said validated Formal Specification further comprises the steps of retrieving the following information from each global interaction defined in said Formal Specification:
name;
arguments including the name and type of each argument; and global interaction formula;
and wherein said step of retrieving information from global functions defined in said validated Formal Specification further comprises the steps of retrieving the following information from each global function defined in said Formal Specification:
name;
return type; and arguments including name and type for each argument.
name;
constant attributes;
variable attributes;
derived attributes;
identification function;
events including the name, arguments for said event including name and type, and precondition formulae;
transactions including, for each said transaction, the name, type, precondition formulae, and transaction formula and arguments including, for each argument, the name and type;
valuation formulae;
state transitions including an initial state, final state, service name, valid agents, and transition condition formula;
static constraints formulae;
dynamic constraints formulae;
trigger conditions formulae;
ancestor class name;
specialized classes including the name, specialization condition formula, precondition redefinitions, and valuation redefinitions;
aggregation relationships including related class, cardinalities, static or dynamic, and role names; and population selection patterns including any filter including any name and filter variables, and/or order criteria specified for said filter;
and wherein said step of retrieving information from global interactions defined in said validated Formal Specification further comprises the steps of retrieving the following information from each global interaction defined in said Formal Specification:
name;
arguments including the name and type of each argument; and global interaction formula;
and wherein said step of retrieving information from global functions defined in said validated Formal Specification further comprises the steps of retrieving the following information from each global function defined in said Formal Specification:
name;
return type; and arguments including name and type for each argument.
5. The process of claim 4 wherein said code generation class stores a list of the translation structures or code generation structures created as requirements data is extracted from the objects of the classes defined in said Formal Specification and stored in the appropriate objects defining said translation structure or code generation classes, and wherein step B comprises the following steps:
looping through the list of instances of translation structures or code generation structures kept by said code generation class which store the requirements data needed to articulate source code components generated by the methods of each translation structure or code generation structure, each said code generation structure being referred to herein as an element, and calling each element's code generation method so as to generate a source code component for that element;
generating a global interaction executive source code component;
generating a global interactions server source code component;
generating a global functions source code component; and generating standard source code components.
looping through the list of instances of translation structures or code generation structures kept by said code generation class which store the requirements data needed to articulate source code components generated by the methods of each translation structure or code generation structure, each said code generation structure being referred to herein as an element, and calling each element's code generation method so as to generate a source code component for that element;
generating a global interaction executive source code component;
generating a global interactions server source code component;
generating a global functions source code component; and generating standard source code components.
6. The process of claim 5 wherein each class in said Formal Specification yields several source code components generated by the methods of several instances of translation structure classes, and wherein the code generation methods of the various instances of translation structure class objects that arise from each said class generate source code components that perform the following functions:
each translation structure in the form of a server class object has a code generation method which uses information stored in said server class object to generate source code of a server component;
each translation structure in the form of a global interaction server class object has a code generation method which uses information stored in said global interaction server class object to generate source code of an executive component that implements global interactions defined in said Conceptual Model with an interface that comprises a method per global interaction defined in said Formal Specification;
each translation structure in the form of analysis class object has a code generation method which uses information stored in said analysis class object to generate a source code that implements an executive component for the class comprising a method per service of the signature of said class, each method structured to generate source code which carries out said service according to an execution model [46/9-10];
each translation structure in the form of a global interactions analysis class object has a code generation method which uses information stored in said global interactions analysis class object to generate source code of an executive component that provides a method per global interaction between objects as defined in global transactions specified in said Formal Specification;
each translation structure in the form of an inheritance hierarchy analysis class object has a code generation method which uses information stored in said inheritance hierarchy analysis class object to generate an executive component which is part of a group of executive components grouped into a single, special executive component for the inheritance hierarchy;
each translation structure in the form of a query class object has a code generation method which uses information stored in said query class object to generate source code of a query component which enables a user of said computer program to query the population of said class;
each translation structure in the form of a T class object has a code generation method which generates T components used to store a copy of the constant and variable attributes of an instance of the corresponding class said class as well as methods to calculate the values of derived attributes said code generation method generating a query component which implements a collection whose items are T
components;
each translation structure in the form of a C class object has a generation method uses information stored in said C class object regarding the initialization values of constant and variable attributes of the corresponding class to generate source code of a C component which functions to populate attributes of instances of said corresponding class with said initialization values;
each translation structure in the form of a CC class object has a code generation method which uses information stored in said CC class object regarding a temporal or permanent, condition-based specialization defined in said Formal Specification to generate the source code of a CC components which implement a collection whose members are C components and provide a pair of methods per C
component to add and get items to the collection and a method to get the number of items in the collection;
each translation structure in the form of P class object has a code generation method which uses information stored in said P class object regarding the values needed to initialize constant and variable attributes of the corresponding class to generate source code of a P component which functions to initialize constant and variable attributes of said corresponding class when creating an instance of it;
each translation structure in the form of a PL class object having a code generation component which uses information stored in said PL class regarding a collection of P components to generate the source code of a PL component which functions to implement a collection of P components and provides methods to add or get items from said collection and get the number of items in said collection;
each translation structure in the form of an arguments list class object has a code generation component which uses information stored in said arguments list class object to provide arguments of every service of every class;
each translation structure in the form of an analysis class list class object has a code generation method that uses information stored in said analysis class list class object on the identification function of every class in said Conceptual Model to generate source code that supplies said identification function information for instances of said class as they are created;
each translation structure taking the form of said one or more event class objects, shared event class objects, transaction class objects, interaction class objects having code generation components uses information stored in said class objects to generate source code components which resolve services in an executive component to implement events, shared events, transactions and object interactions;
each translation structure taking the form of said one or more auxiliary methods class objects having code generation methods which use information in said auxiliary methods class objects to generate source code components which resolve a service in both executive components and executive components for inheritance hierarchies so as to implement at least precondition classes, static constraint classes, and dynamic constraint classes if preconditions, static constraints and dynamic constraints are present in said Conceptual Model;
each translation structure taking the form of a T&Q class object having a code generation method using information stored in said T&Q class object to generate source code components that implement queries and T components; and each translation structure taking the form of an inheritance method class object having a code generation method which uses information stored in said inheritance method class object for generating source code components to implement methods specific to inheritance relationships specified for the corresponding class in said Formal Specification.
each translation structure in the form of a server class object has a code generation method which uses information stored in said server class object to generate source code of a server component;
each translation structure in the form of a global interaction server class object has a code generation method which uses information stored in said global interaction server class object to generate source code of an executive component that implements global interactions defined in said Conceptual Model with an interface that comprises a method per global interaction defined in said Formal Specification;
each translation structure in the form of analysis class object has a code generation method which uses information stored in said analysis class object to generate a source code that implements an executive component for the class comprising a method per service of the signature of said class, each method structured to generate source code which carries out said service according to an execution model [46/9-10];
each translation structure in the form of a global interactions analysis class object has a code generation method which uses information stored in said global interactions analysis class object to generate source code of an executive component that provides a method per global interaction between objects as defined in global transactions specified in said Formal Specification;
each translation structure in the form of an inheritance hierarchy analysis class object has a code generation method which uses information stored in said inheritance hierarchy analysis class object to generate an executive component which is part of a group of executive components grouped into a single, special executive component for the inheritance hierarchy;
each translation structure in the form of a query class object has a code generation method which uses information stored in said query class object to generate source code of a query component which enables a user of said computer program to query the population of said class;
each translation structure in the form of a T class object has a code generation method which generates T components used to store a copy of the constant and variable attributes of an instance of the corresponding class said class as well as methods to calculate the values of derived attributes said code generation method generating a query component which implements a collection whose items are T
components;
each translation structure in the form of a C class object has a generation method uses information stored in said C class object regarding the initialization values of constant and variable attributes of the corresponding class to generate source code of a C component which functions to populate attributes of instances of said corresponding class with said initialization values;
each translation structure in the form of a CC class object has a code generation method which uses information stored in said CC class object regarding a temporal or permanent, condition-based specialization defined in said Formal Specification to generate the source code of a CC components which implement a collection whose members are C components and provide a pair of methods per C
component to add and get items to the collection and a method to get the number of items in the collection;
each translation structure in the form of P class object has a code generation method which uses information stored in said P class object regarding the values needed to initialize constant and variable attributes of the corresponding class to generate source code of a P component which functions to initialize constant and variable attributes of said corresponding class when creating an instance of it;
each translation structure in the form of a PL class object having a code generation component which uses information stored in said PL class regarding a collection of P components to generate the source code of a PL component which functions to implement a collection of P components and provides methods to add or get items from said collection and get the number of items in said collection;
each translation structure in the form of an arguments list class object has a code generation component which uses information stored in said arguments list class object to provide arguments of every service of every class;
each translation structure in the form of an analysis class list class object has a code generation method that uses information stored in said analysis class list class object on the identification function of every class in said Conceptual Model to generate source code that supplies said identification function information for instances of said class as they are created;
each translation structure taking the form of said one or more event class objects, shared event class objects, transaction class objects, interaction class objects having code generation components uses information stored in said class objects to generate source code components which resolve services in an executive component to implement events, shared events, transactions and object interactions;
each translation structure taking the form of said one or more auxiliary methods class objects having code generation methods which use information in said auxiliary methods class objects to generate source code components which resolve a service in both executive components and executive components for inheritance hierarchies so as to implement at least precondition classes, static constraint classes, and dynamic constraint classes if preconditions, static constraints and dynamic constraints are present in said Conceptual Model;
each translation structure taking the form of a T&Q class object having a code generation method using information stored in said T&Q class object to generate source code components that implement queries and T components; and each translation structure taking the form of an inheritance method class object having a code generation method which uses information stored in said inheritance method class object for generating source code components to implement methods specific to inheritance relationships specified for the corresponding class in said Formal Specification.
7. The process of claim 1 further comprising the steps:
C) controlling a computer to display diagrams and textual interactive dialogs which a designer of said computer program uses to enter requirements data that defines the desired structure and behavior of said computer program, and wherein said diagram and textual interactive dialogs are such that only information relevant for filling a class definition in the formal language being used to write said Formal Specification can be entered;
D) storing said requirements data entered using said diagrams and textual interactive dialogs as said Formal Specification written in a formal language having rules of syntax and semantics that define a grammar;
E) controlling a computer to use said rules of syntax and semantics to validate said Formal Specification to ensure it is correct and complete.
C) controlling a computer to display diagrams and textual interactive dialogs which a designer of said computer program uses to enter requirements data that defines the desired structure and behavior of said computer program, and wherein said diagram and textual interactive dialogs are such that only information relevant for filling a class definition in the formal language being used to write said Formal Specification can be entered;
D) storing said requirements data entered using said diagrams and textual interactive dialogs as said Formal Specification written in a formal language having rules of syntax and semantics that define a grammar;
E) controlling a computer to use said rules of syntax and semantics to validate said Formal Specification to ensure it is correct and complete.
8. The process of claim 7 wherein said diagrams and textual interactive dialogs are structured to allow said designer to enter requirements data defining classes, relationships between classes, global transactions, global functions and views, and wherein said diagrams and textual interactive dialogs are further structured to allow said designer to enter requirements data defining:
- Attributes;
- Services;
- Derivations;
- Constraints;
- transaction formulas;
- triggers;
- display sets;
- filters;
- population selection patterns;
- a state transition diagram;
- a name;
- an alias; and - a default population selection interface pattern.
- Attributes;
- Services;
- Derivations;
- Constraints;
- transaction formulas;
- triggers;
- display sets;
- filters;
- population selection patterns;
- a state transition diagram;
- a name;
- an alias; and - a default population selection interface pattern.
9. The process of claim 8 wherein said diagrams and textual interactive dialogs are such that said designer can define said attributes by entering requirements data defining for each attribute:
- a name;
- a formal attribute type of constant, variable or derived;
- a data type;
- a default value;
- whether the attribute is an identifier for distinguishing objects of the class to which it belongs;
- a length;
- whether the attribute is required when the object is created;
- whether the attribute can be assigned a null value;
- information about valuations that define as a formula how the value of the attribute is changed by the occurrence of an event; and - optional information about user interface patterns to be applied in corresponding service arguments related to the attribute.
- a name;
- a formal attribute type of constant, variable or derived;
- a data type;
- a default value;
- whether the attribute is an identifier for distinguishing objects of the class to which it belongs;
- a length;
- whether the attribute is required when the object is created;
- whether the attribute can be assigned a null value;
- information about valuations that define as a formula how the value of the attribute is changed by the occurrence of an event; and - optional information about user interface patterns to be applied in corresponding service arguments related to the attribute.
10. The process of claim 9 wherein said diagrams and textual interactive dialogs are such as to allow said designer to define said services by entering requirements data defining for each service:
- whether the service is an event or transaction;
- a name;
- service alias;
- whether the event is shared if the service is an event;
- a transaction formula that expresses the composition of services if the service is a transaction;
- a list of arguments and, for each argument: its name, data type, whether nulls are allowed as a valid value, whether the argument represents a set of objects in a collection, a default value, an alias, user interface patterns related to arguments including: introduction pattern, population selection pattern, defined selection pattern and dependency pattern.
- whether the service is an event or transaction;
- a name;
- service alias;
- whether the event is shared if the service is an event;
- a transaction formula that expresses the composition of services if the service is a transaction;
- a list of arguments and, for each argument: its name, data type, whether nulls are allowed as a valid value, whether the argument represents a set of objects in a collection, a default value, an alias, user interface patterns related to arguments including: introduction pattern, population selection pattern, defined selection pattern and dependency pattern.
11. The process of claim 10 wherein said diagrams and textual interactive dialogs are such that said designer can further define each class by entering requirements data defining derivations, constraints, triggers, display sets, filters, population selection user interface patterns, wherein each derivation specifies a list of condition-formula pairs and specifying which formula will be applied under every condition, and wherein each constraint is a formula plus an error message the designer specifies which will be displayed when said constraint specified by said designer is violated, and wherein each trigger may be composed of a trigger target specified as self, class or object, a trigger condition and a triggered action comprised of a service and a list of possible agents to activate said service and a list of values associated with the arguments of the related service, and wherein each display set defines which attributes of said class will be visible to the user, and each filter is comprised of a formula and a list of auxiliary variables that are useful to define said formula, and wherein said population selection user interface pattern is defined by a display set and a filter, and wherein said diagrams and textual interactive dialogs are such as to allow said designer to enter a state transition diagram for each class which is a set of states and transitions between them where each transition occurs upon occurrence of an action that can change the state of an object in said class, and wherein said actions can have preconditions which are entered by said designer as formulas that need to be satisfied before an action can be executed.
12. The process of claim 11 wherein said diagrams and textual interactive dialogs are such that said designer can enter requirements data defining the relationships between classes which can be either aggregation or inheritance, wherein each aggregation relationship is indicated by requirements data which specifies the composition of objects in the aggregation relationship and which specified cardinalities and whether the aggregation is static or dynamic and whether the aggregation is inclusive or referential and whether the aggregation has an identification dependence and a grouping clause when the aggregation is multi-valued, and wherein each inheritance relationship is defined by requirements data entered by the designer which specifies specialization of objects and stores the name of the parent class, the name of the child class and whether the specialization is temporary or permanent, and if the specialization is permanent, stores a formula on constant attributes as a specialization condition, and, if the specialization is temporary, the requirements data indicates the condition or the list of events that activate or deactivate the child role, and wherein said diagrams and textual interactive dialogues also are such that a designer can enter as requirements data a list of global transactions including the name of the global interaction, the formula and a list of arguments and can enter a list of global functions including the name, a data type of a returned value and a set of arguments.
13. The process of claim 5 further comprising the steps:
controlling a computer to display diagrams and textual interactive dialogs which a designer of said computer program uses to enter requirements data that defines the desired system logic and user interface of said computer program and wherein said diagram and textual interactive dialogs are such that only information relevant for filling a class definition in the formal language being used to write said Formal Specification can be entered;
- storing said requirements data entered using said diagrams and textual interactive dialogs as said Formal Specification written in a formal language having rules of syntax and semantics that define a grammar;
- controlling a computer to use said rules of syntax and semantics to validate said Formal Specification to generate said validated Formal Specification.
controlling a computer to display diagrams and textual interactive dialogs which a designer of said computer program uses to enter requirements data that defines the desired system logic and user interface of said computer program and wherein said diagram and textual interactive dialogs are such that only information relevant for filling a class definition in the formal language being used to write said Formal Specification can be entered;
- storing said requirements data entered using said diagrams and textual interactive dialogs as said Formal Specification written in a formal language having rules of syntax and semantics that define a grammar;
- controlling a computer to use said rules of syntax and semantics to validate said Formal Specification to generate said validated Formal Specification.
14. The process of claim 13 wherein said diagrams and textual interactive dialogs are structured to allow said designer to enter requirements data defining classes, relationships between classes, global transactions, global functions and views, and wherein said diagrams and textual interactive dialogs are further structured to allow said designer to enter requirements data defining:
- attributes;
- services;
- derivations;
- constraints;
- transaction formulas;
- triggers;
- display sets;
- filters;
- population selection patterns;
- a state transition diagram;
- a name;
- an alias; and - a default population selection interface pattern.
- attributes;
- services;
- derivations;
- constraints;
- transaction formulas;
- triggers;
- display sets;
- filters;
- population selection patterns;
- a state transition diagram;
- a name;
- an alias; and - a default population selection interface pattern.
15. The process of claim 14 wherein said diagrams and textual interactive dialogs are such that said designer can define said attributes by entering requirements data defining for each attribute:
- a name;
- a formal attribute type of constant, variable or derived;
- a data type;
- a default value;
- whether the attribute is an identifier for distinguishing objects of the class to which it belongs;
- a length;
- whether the attribute is required when the object is created;
- whether the attribute can be assigned a null value;
- information about valuations that define as a formula how the value of the attribute is changed by the occurrence of an event; and - optional information about user interface patterns to be applied in corresponding service arguments related to the attribute.
- a name;
- a formal attribute type of constant, variable or derived;
- a data type;
- a default value;
- whether the attribute is an identifier for distinguishing objects of the class to which it belongs;
- a length;
- whether the attribute is required when the object is created;
- whether the attribute can be assigned a null value;
- information about valuations that define as a formula how the value of the attribute is changed by the occurrence of an event; and - optional information about user interface patterns to be applied in corresponding service arguments related to the attribute.
16. The process of claim 15 wherein said diagrams and textual interactive dialogs are such as to allow said designer to define said services by entering requirements data defining for each service:
- whether the service is an event or transaction;
- a name;
- service alias;
- whether the event is shared if the service is an event;
- a transaction formula that expresses the composition of services if the service is a transaction;
- a list of arguments and, for each argument: its name, data type, whether nulls are allowed as a valid value, whether the argument represents a set of objects in a collection, a default value, an alias, user interface patterns related to arguments including: introduction pattern, population selection pattern, defined selection pattern and dependency pattern.
- whether the service is an event or transaction;
- a name;
- service alias;
- whether the event is shared if the service is an event;
- a transaction formula that expresses the composition of services if the service is a transaction;
- a list of arguments and, for each argument: its name, data type, whether nulls are allowed as a valid value, whether the argument represents a set of objects in a collection, a default value, an alias, user interface patterns related to arguments including: introduction pattern, population selection pattern, defined selection pattern and dependency pattern.
17. The process of claim 16 wherein said diagrams and textual interactive dialogs are such that said designer can further define each class by entering requirements data defining derivations, constraints, triggers, display sets, filters, population selection user interface patterns, wherein each derivation specifies a list of condition-formula pairs and specifying which formula will be applied under every condition, and wherein each constraint is a formula plus an error message the designer specifies which will be displayed when said constraint specified by said designer is violated, and wherein each trigger may be composed of a trigger target specified as self, class or object, a trigger condition and a triggered action comprised of a service and a list of possible agents to be activate said service and a list of default values associated with the arguments of the related service, and wherein each display set defines which attributes of said class will be visible to the user, and each filter is comprised of a formula and a list of auxiliary variables that are useful to define said formula, and wherein said population selection user interface pattern is defined by a display set and a filter, and wherein said diagrams and textual interactive dialogs are such as to allow said designer to enter a state transition diagram for each class which is a set of states and transitions between them where each transition occurs upon occurrence of an action that can change the state of an object in said class, and wherein said actions can have preconditions which are entered by said designer as formulas that need to be satisfied before an action can be executed.
18. The process of claim 17 wherein said diagrams and textual interactive dialogs are such that said designer can enter information on the relationships between classes which can be either aggregation or inheritance, wherein each aggregation relationship is indicated by requirements data which specifies the composition of objects in the aggregation relationship and which specifies cardinalities and whether the aggregation is static or dynamic and whether the aggregation is inclusive or referential and whether the aggregation has an identification dependence and a grouping clause when the aggregation is multi-valued, and wherein each inheritance relationship is defined by requirements data entered by the designer which specifies specialization of objects and stores the name of the parent class, the name of the child class and whether the specialization is temporary or permanent, and if the specialization is permanent, stores a formula on constant attributes as a specialization condition, and, if the specialization is temporary, the requirements data indicates the condition or the list of events that activate or deactivate the child role, and wherein said diagrams and textual interactive dialogues also are such that a designer can enter as requirements data a list of global transactions including the name of the global interaction, the formula and a list of arguments and can enter a list of global functions including the name, a data type of a returned value and a set of arguments.
19. The process of claim 6 wherein each said method to carry out a service implemented by a said executive component includes the following steps:
verify the existence and validity for the requested server instance;
create a copy of the requested server instance in memory accessing the persistence layer (by means of a corresponding query component) to retrieve the values of constant and variable attributes;
validate state transition for the requested service and the present state of the requested server instance as specified in the corresponding state transition diagram in the Conceptual Model;
verify the satisfaction of the requested service preconditions;
modify the value of the instance variable attributes by performing all valuations affected by the service as specified in said Conceptual Model, thus changing the state of the requested server instance;
validate the new state achieved by the requested server instance by verifying its static and dynamic restrictions;
S heck trigger conditions to determine which actions should be triggered if needed;
communicate with a persistence layer for all persistent attributes of the requested server instance.
verify the existence and validity for the requested server instance;
create a copy of the requested server instance in memory accessing the persistence layer (by means of a corresponding query component) to retrieve the values of constant and variable attributes;
validate state transition for the requested service and the present state of the requested server instance as specified in the corresponding state transition diagram in the Conceptual Model;
verify the satisfaction of the requested service preconditions;
modify the value of the instance variable attributes by performing all valuations affected by the service as specified in said Conceptual Model, thus changing the state of the requested server instance;
validate the new state achieved by the requested server instance by verifying its static and dynamic restrictions;
S heck trigger conditions to determine which actions should be triggered if needed;
communicate with a persistence layer for all persistent attributes of the requested server instance.
20. The process of claim 1 wherein each said element of said Formal Specification corresponds to a conceptual pattern or building block of a Conceptual Model of said computer program to be automatically written, and wherein said building blocks from which each class in said Object Model of said Conceptual Model is built comprise:
- a name;
- an identification function that characterizes the naming mechanism used by objects in said class;
- an alias;
- constant, variable and derived attributes;
- a set of services including private and shared events and local transactions;
-display sets, filters and population selection patterns;
- a set of states and transitions between them;
- integrity constraints;
- derivation expressions that define the values of derived attributes;
- aggregation and inheritance class operators;
and wherein building blocks used by said analyst to construct said Dynamic Model component of said Conceptual Model comprise:
- action preconditions;
- the process specification of a class to specify valid object lives;
- trigger relationships;
- global transactions;
and wherein building blocks used by said analyst to construct a Functional Model component of said Conceptual Model comprise valuation dynamic formulas which specify the effect of events on the values of attributes;
and wherein building blocks which define a pattern language and which are used by said analyst to build said User Interface (Presentation) Model defining the desired user interface of said computer program to be automatically written, comprise:
- a service presentation pattern having elemental patterns that articulate it comprising patterns of.
introduction;
defined selection;
population selection;
supplementary information;
dependency;
status recovery;
argument grouping;
- a class population presentation pattern having elemental patterns used to articulate it comprising patterns for defining:
a filter;
order criterion;
display set;
- an instance presentation pattern having elemental patterns used to articulate it comprising a pattern for defining:
a display set;
- a master/detail presentation pattern having elemental patterns used to articulate it comprising:
instance presentation;
class population presentation;
recursively, master-detail presentation;
- an action selection pattern.
- a name;
- an identification function that characterizes the naming mechanism used by objects in said class;
- an alias;
- constant, variable and derived attributes;
- a set of services including private and shared events and local transactions;
-display sets, filters and population selection patterns;
- a set of states and transitions between them;
- integrity constraints;
- derivation expressions that define the values of derived attributes;
- aggregation and inheritance class operators;
and wherein building blocks used by said analyst to construct said Dynamic Model component of said Conceptual Model comprise:
- action preconditions;
- the process specification of a class to specify valid object lives;
- trigger relationships;
- global transactions;
and wherein building blocks used by said analyst to construct a Functional Model component of said Conceptual Model comprise valuation dynamic formulas which specify the effect of events on the values of attributes;
and wherein building blocks which define a pattern language and which are used by said analyst to build said User Interface (Presentation) Model defining the desired user interface of said computer program to be automatically written, comprise:
- a service presentation pattern having elemental patterns that articulate it comprising patterns of.
introduction;
defined selection;
population selection;
supplementary information;
dependency;
status recovery;
argument grouping;
- a class population presentation pattern having elemental patterns used to articulate it comprising patterns for defining:
a filter;
order criterion;
display set;
- an instance presentation pattern having elemental patterns used to articulate it comprising a pattern for defining:
a display set;
- a master/detail presentation pattern having elemental patterns used to articulate it comprising:
instance presentation;
class population presentation;
recursively, master-detail presentation;
- an action selection pattern.
21. An apparatus for automatically generating a computer program from a validated Formal Specification of the desired structure and behavior of said computer program and its user interface, said Formal Specification written in a formal language, comprising:
a computer having a memory; and one or more computer programs stored in said computer which, when executed, cause said computer to perform the following steps:
articulating code generation structures referred to as translation structures and which are stored in said memory using requirements data extracted from a high level system repository storing said Formal Specification; and executing said method of each said translation structure to write a source code component instantiated with requirements data from said translation structure in said high level repository, and including the resulting source code components in a file of source code components, and generating source code for global interaction executive components and source code for global interaction server components, and generating source code for global functions components and generating standard source code components and combining all said components into a file which is said computer program.
a computer having a memory; and one or more computer programs stored in said computer which, when executed, cause said computer to perform the following steps:
articulating code generation structures referred to as translation structures and which are stored in said memory using requirements data extracted from a high level system repository storing said Formal Specification; and executing said method of each said translation structure to write a source code component instantiated with requirements data from said translation structure in said high level repository, and including the resulting source code components in a file of source code components, and generating source code for global interaction executive components and source code for global interaction server components, and generating source code for global functions components and generating standard source code components and combining all said components into a file which is said computer program.
22. The apparatus of claim 21 wherein said memory of said computer stores said translation structures as classes, each of said translation structure being articulated by storing requirements data therein which is entered by a designer of said computer program while building said Conceptual Model of said computer program, each piece of requirements data information or conceptual pattern in said Conceptual Model having a corresponding formal counterpart in said Formal Specification represented as a formal language concept and stored in one of said translation structures, and wherein one or more of said translation structures store requirements data which defines a template for each class, each template comprised of several elemental building blocks each of which is stored in a translation structure in the form of a class and which combine to define each said template for each said class, the building blocks for each said class and the elemental building blocks which make up the class being used to construct an Object Model portion of said Conceptual Model, said elemental building blocks that make up each class building block comprising:
- a name;
- an identification function that characterizes the naming mechanism used by objects in said class;
- an alias;
- constant, variable and derived attributes;
- a set of services including private and shared events and local transactions;
- integrity constraints; - derivation expressions that define the values of derived attributes;
- aggregation and inheritance class operators;
and wherein building blocks used by said designer to construct a Dynamic Model component of said Conceptual Model comprise:
- action preconditions;
- the process definition of a class to specify valid object lives;
- trigger relationships;
- global transactions;
and wherein building blocks used by said analyst to construct a Functional Model component of said Conceptual Model comprise valuations dynamic formulas which specify the effect of events on the values of attributes;
and wherein building blocks which define a pattern language and which are used by said analyst to build said Presentation model defining the desired user interface of said computer program to be automatically written, comprise:
- a service presentation pattern having elemental patterns that articulate it comprising patterns of:
introduction;
defined selection;
supplementary information;
dependency;
status recovery;
argument grouping;
- a class population presentation pattern having elemental patterns used to articulate it comprising patterns for defining:
a filter;
order criterion;
display set;
- an instance presentation pattern having elemental patterns used to articulate it comprising patterns for defining:
a display set;
- a master/detail presentation pattern; and -an action selection pattern.
- a name;
- an identification function that characterizes the naming mechanism used by objects in said class;
- an alias;
- constant, variable and derived attributes;
- a set of services including private and shared events and local transactions;
- integrity constraints; - derivation expressions that define the values of derived attributes;
- aggregation and inheritance class operators;
and wherein building blocks used by said designer to construct a Dynamic Model component of said Conceptual Model comprise:
- action preconditions;
- the process definition of a class to specify valid object lives;
- trigger relationships;
- global transactions;
and wherein building blocks used by said analyst to construct a Functional Model component of said Conceptual Model comprise valuations dynamic formulas which specify the effect of events on the values of attributes;
and wherein building blocks which define a pattern language and which are used by said analyst to build said Presentation model defining the desired user interface of said computer program to be automatically written, comprise:
- a service presentation pattern having elemental patterns that articulate it comprising patterns of:
introduction;
defined selection;
supplementary information;
dependency;
status recovery;
argument grouping;
- a class population presentation pattern having elemental patterns used to articulate it comprising patterns for defining:
a filter;
order criterion;
display set;
- an instance presentation pattern having elemental patterns used to articulate it comprising patterns for defining:
a display set;
- a master/detail presentation pattern; and -an action selection pattern.
23. The apparatus of claim 22 wherein said one or more computer programs includes an editor program to control said computer to display graphical diagrams and textual interactive dialogs which said designer uses to enter requirements data in said Conceptual Model and convert each piece of requirements data into its formal counterpart in said Formal Specification that defines the desired structure and behavior of said computer program to be automatically written, said editor program controlling said computer to use rules of grammar defined by the formal language in which said Formal Specification is written to validate said Formal Specification to ensure it is complete and correct.
24. An apparatus comprising a software production system to facilitate design and automatic writing of a Formal Specification written in a formal language which fully defines the structure, function and user interface of a computer program the source code of which is to be automatically written (hereafter referred to as the application program), comprising:
a computer having a memory, said memory storing translation structures, each translation structure comprising a class to store information needed to generate a source code component, and having a method to generate said source code component using said information stored in said translation structure, said information stored in said translation structure comprising information retrieved from a Formal Specification that is generated from a Conceptual Model;
an editor program loaded on said computer which, when executed by said computer, controls said computer to display diagrams and textual interactive dialogs in an editor window which can be used by a designer of said application to build a Conceptual Model, said editor program structured to control said computer to receive requirements data entered by a designer of said application using said displayed diagrams and textual interactive dialogs and convert each piece of requirements data information into its corresponding formal counterpart in a formal language and store said corresponding formal counterpart in a Formal Specification which acts as a system repository; and a validation program, which, when executed by said computer, controls said computer to use the rules of grammar of said formal language in which said Formal Specification is written to validate each said corresponding formal counterpart to ensure it is complete and correct.
a computer having a memory, said memory storing translation structures, each translation structure comprising a class to store information needed to generate a source code component, and having a method to generate said source code component using said information stored in said translation structure, said information stored in said translation structure comprising information retrieved from a Formal Specification that is generated from a Conceptual Model;
an editor program loaded on said computer which, when executed by said computer, controls said computer to display diagrams and textual interactive dialogs in an editor window which can be used by a designer of said application to build a Conceptual Model, said editor program structured to control said computer to receive requirements data entered by a designer of said application using said displayed diagrams and textual interactive dialogs and convert each piece of requirements data information into its corresponding formal counterpart in a formal language and store said corresponding formal counterpart in a Formal Specification which acts as a system repository; and a validation program, which, when executed by said computer, controls said computer to use the rules of grammar of said formal language in which said Formal Specification is written to validate each said corresponding formal counterpart to ensure it is complete and correct.
25. The apparatus of claim 24 further comprising a system logic translator for automatically generating source code from information in said system repository, a user interface translator which automatically generates source code for a software component that implements user interface functionality defined by information in said Formal Specification stored in said system repository, and a database generator that automatically defines a data model in a Relational Database Management System using information in said system repository.
26. The apparatus of claim 25 further comprising memory structures referred to as translation structures which are class data structures stored in said memory which store requirements data entered by said designer to build said Conceptual Model and each of which has a method to generate source code using said requirements data stored in said translation structure, one of said translation structure class data structures being a code generation class which functions to retrieve all the requirements data from said translation structures needed to generate source code in the appropriate order and write automatically generated source code to files and organize said automatically generated source code into files properly according to a component-based structure to create said application program, a subset of said requirements data being retrieved from said system repository by each of said system logic translator, user interface translator or database generator, said translators controlling said computer to automatically retrieve requirements data from said system repository and store it in said translation structures and to generate source code components using a subset of said requirements data stored in said translation structures, said system logic translator generating source code based upon a subset of requirements data retrieved from said system repository said requirements data retrieved by said system logic translator being based upon the main unit of information in the Conceptual Model which is classes and other units of information in said Conceptual Model which are global transactions and global functions, said information being retrieved from the classes defined in said Conceptual Model comprising:
-Name;
-Identification function;
-Events including name, arguments and precondition formula;
-Transactions including name, type whether local or global, arguments, precondition formula, and transaction formula;
-Constant Attributes;
-Variable Attributes;
-Derived Attributes including name, type and derivation formulas;
-Aggregation Class Relationships including related class, cardinalities, static or dynamic and role names;
-Agent relationships between classes;
-Valuation formulas;
-Static Constraints Formulas;
-Dynamic Constraints Formulas;
-Trigger Conditions Formulas;
-Ancestor Class;
-Specialized Classes including names, specialization condition formulas, precondition re-definitions and valuation re-definitions;
-State Transitions including initial state, final state, service name, valid agents and transition condition formula;
and information being retrieved from global interactions defined in said Conceptual Model comprising:
-Name;
-Arguments including name and type; and -Global Interaction Formula;
and information being retrieved from global functions defined in said Conceptual Model comprising:
-Name;
-Return Type; and -Arguments including name and type.
-Name;
-Identification function;
-Events including name, arguments and precondition formula;
-Transactions including name, type whether local or global, arguments, precondition formula, and transaction formula;
-Constant Attributes;
-Variable Attributes;
-Derived Attributes including name, type and derivation formulas;
-Aggregation Class Relationships including related class, cardinalities, static or dynamic and role names;
-Agent relationships between classes;
-Valuation formulas;
-Static Constraints Formulas;
-Dynamic Constraints Formulas;
-Trigger Conditions Formulas;
-Ancestor Class;
-Specialized Classes including names, specialization condition formulas, precondition re-definitions and valuation re-definitions;
-State Transitions including initial state, final state, service name, valid agents and transition condition formula;
and information being retrieved from global interactions defined in said Conceptual Model comprising:
-Name;
-Arguments including name and type; and -Global Interaction Formula;
and information being retrieved from global functions defined in said Conceptual Model comprising:
-Name;
-Return Type; and -Arguments including name and type.
27. The apparatus of claim 26 wherein said user interface translator controls said computer to retrieve a subset of requirements data from said system repository and store it in said translation structures and call the method of said code generation class to retrieve from said translation structures a subset of requirements data needed to generate said source code component that implements user interface functionality and call in the right order the methods of said translation structures needed to generate the source code files that make up the source code component that implements user interface functionality, said source code component implementing user functionality structured to control a computer which executes it to display said desired user interface as forms that contain the user-interface offered to the user, said forms comprising:
- an access form to authenticate the user as valid service agent object by requesting an object identifier and a password;
- a main form to provide a system view of the services the user can launch in the form of a menu where the user can view the services he can launch;
- an activation service form for every service the user can launch, said activation service form having an introduction field for every argument the user must provide, the source code of said activation service form being structured to validate data-types, sizes, value-range, nulls of any data introduced by said user and code to build and send a service activation message if all arguments have been validated to be proper;
- a query selection form for each class defined in the Formal Specification to allow users of said application to query data instances, search instances that fulfill a given condition, observe related instances and know which services a user can launch for a given object in a given state, said source code structured to display visual components to launch services and determine which service of which object to launch given a user's command to launch a service, said source code also structured to display a component for browsing which allows a user to navigate by following a link from an object to display a new query/selection form which displays only information about the previous object;
and wherein said source code component that implements user interface functionality is comprised of fixed files with fixed content corresponding to structures or auxiliary functions which are widely used and are always produced in the same way and variable files of source code which have content which strongly depends upon the requirements data in said Conceptual Model encoded in said Formal Specification stored in said system repository but which have well defined structure in the sense that said variable filed are templates of source code with well-defined structure so as to implement the various forms defined above but which have variable parts of said source code which depends upon the requirements data extracted from said Conceptual Model so as to implement the actual user interface designed by the designer who constructed said Conceptual Model.
- an access form to authenticate the user as valid service agent object by requesting an object identifier and a password;
- a main form to provide a system view of the services the user can launch in the form of a menu where the user can view the services he can launch;
- an activation service form for every service the user can launch, said activation service form having an introduction field for every argument the user must provide, the source code of said activation service form being structured to validate data-types, sizes, value-range, nulls of any data introduced by said user and code to build and send a service activation message if all arguments have been validated to be proper;
- a query selection form for each class defined in the Formal Specification to allow users of said application to query data instances, search instances that fulfill a given condition, observe related instances and know which services a user can launch for a given object in a given state, said source code structured to display visual components to launch services and determine which service of which object to launch given a user's command to launch a service, said source code also structured to display a component for browsing which allows a user to navigate by following a link from an object to display a new query/selection form which displays only information about the previous object;
and wherein said source code component that implements user interface functionality is comprised of fixed files with fixed content corresponding to structures or auxiliary functions which are widely used and are always produced in the same way and variable files of source code which have content which strongly depends upon the requirements data in said Conceptual Model encoded in said Formal Specification stored in said system repository but which have well defined structure in the sense that said variable filed are templates of source code with well-defined structure so as to implement the various forms defined above but which have variable parts of said source code which depends upon the requirements data extracted from said Conceptual Model so as to implement the actual user interface designed by the designer who constructed said Conceptual Model.
28. The apparatus of claim 27 wherein said user interface translator calls the method of code generation class to perform the following tasks:
-generate said fixed files;
-generate auxiliary widgets in the form of controls or Java Beans;
-for each class, generate said query/selection form, an instance selection component, a specialization component if the class is specialized from other classes;
-for each service, generate said activation service form;
-generate said access form to allow a user of said application program to authenticate himself;
-generate said main form containing the system view of the services a user which has logged in successfully through said access form can launch;
-generate source code of communication functions to send service activation messages to servers in the system logic of said application program.
-generate said fixed files;
-generate auxiliary widgets in the form of controls or Java Beans;
-for each class, generate said query/selection form, an instance selection component, a specialization component if the class is specialized from other classes;
-for each service, generate said activation service form;
-generate said access form to allow a user of said application program to authenticate himself;
-generate said main form containing the system view of the services a user which has logged in successfully through said access form can launch;
-generate source code of communication functions to send service activation messages to servers in the system logic of said application program.
29. The apparatus of claim 26 wherein said translation structure classes comprise:
a server class to store information needed to generate server components;
a global interactions server class to store information needed to generate server components for global interactions;
an analysis class to store information needed to generate executive components;
a global interactions analysis class to store information needed to generate executive components for global interactions in the form of names of global interactions, global transactions formulas and a list of arguments;
an inheritance hierarchy analysis class to store information needed to generate executive components for inheritance hierarchies;
a query class to store information needed to generate query components;
a T class to store information needed to generate T components;
a C class to store information needed to generate C components;
a CC class to store information needed to generate CC component;
a P class to store information needed to generate P components;
a PL class to store information needed to generate PL components;
an arguments list class to store information on the arguments for every service of every class in said Conceptual Model [50/9-10];
an analysis class list class to store information on the identification function of every class in the Conceptual Model [50/10-11];
one or more classes to generate the methods needed to resolve a service in executive components to implement events, shared events, transactions and object interactions (hereafter referred to as events classes) [50/11-13];
one or more classes to generate the auxiliary methods needed to resolve a service in both executive components and executive components for inheritance hierarchies to implement at least precondition classes, static constraint classes, dynamic constraint classes if preconditions, static constraints and dynamic constraints are present in said Conceptual Model (hereafter referred to as auxiliary methods classes) [50/11-13]
T & Q method classes to generate methods needed in query and T components [50/16-17];
an inheritance method class to generate inheritance-specific methods [50/17-18]; and a code generation class to control and implement a code generation process.
a server class to store information needed to generate server components;
a global interactions server class to store information needed to generate server components for global interactions;
an analysis class to store information needed to generate executive components;
a global interactions analysis class to store information needed to generate executive components for global interactions in the form of names of global interactions, global transactions formulas and a list of arguments;
an inheritance hierarchy analysis class to store information needed to generate executive components for inheritance hierarchies;
a query class to store information needed to generate query components;
a T class to store information needed to generate T components;
a C class to store information needed to generate C components;
a CC class to store information needed to generate CC component;
a P class to store information needed to generate P components;
a PL class to store information needed to generate PL components;
an arguments list class to store information on the arguments for every service of every class in said Conceptual Model [50/9-10];
an analysis class list class to store information on the identification function of every class in the Conceptual Model [50/10-11];
one or more classes to generate the methods needed to resolve a service in executive components to implement events, shared events, transactions and object interactions (hereafter referred to as events classes) [50/11-13];
one or more classes to generate the auxiliary methods needed to resolve a service in both executive components and executive components for inheritance hierarchies to implement at least precondition classes, static constraint classes, dynamic constraint classes if preconditions, static constraints and dynamic constraints are present in said Conceptual Model (hereafter referred to as auxiliary methods classes) [50/11-13]
T & Q method classes to generate methods needed in query and T components [50/16-17];
an inheritance method class to generate inheritance-specific methods [50/17-18]; and a code generation class to control and implement a code generation process.
30. The process of claim 29 further comprising the step of executing the methods of each translation structure class to generate source code components of said application, and wherein said translation structure class methods each perform the following functions to generate source code components to perform the following functions in said application:
each server class instance code generation method uses information stored in said server class instance to generate a server source code component that comprises a method for each service present in the signature of said class;
each global interaction server class code generation method uses information stored in said global interaction server class to generate a source code component that implements global interactions defined in said Conceptual Model with an interface that comprises a method per global interaction defined in said Formal Specification;
each analysis class instance code generation method uses information stored in said analysis class instance to generate a source code component that implements an executive component for the class which yielded said analysis class instance translation structure, said executive component comprising a method per service of the signature of said class which gave rise to said analysis class instance, each method structured to carry out said service according to an execution model;
each global interactions analysis class code generation method uses information stored in said global interactions analysis class to generate a source code component that implements an executive component that provides a method per service implementing global interactions between objects as defined in global transactions specified in said Formal Specification;
each inheritance hierarchy analysis class code generation method uses information stored in said inheritance hierarchy analysis class to generate a source code component that implements an executive component which is part of a group of executive components grouped into a single, special executive component for the inheritance hierarchy;
each query class code generation method uses information stored in said query class to generate a source code component that implements query components which enable a user of said computer program to query the population of said class;
each T class code generation method uses information stored in said T
classregarding the constant and variable attributes of said class which gave rise to said instance of said T class and the methods to calculate the values of derived attributes to generate source code of a T component which provides query access to values of constant and derived attributes and calculates the values of derived attributes of said class;
each C class code generation method uses information stored in said C class regarding the initialization values of constant and variable attributes of said class to generate source code of a C component which functions to populate attributes of said class with said initialization values when creating an instance of said class if said class is a temporal or permanent, condition-based specialization class;
each CC class code generation method uses information stored in said CC
class regarding a temporal or permanent, condition-based specialization defined in said Formal Specification to generate the source code which implement CC
components which implement a collection of C components and provide a pair of methods per C component to add and get items to the collection and a method to get the number of items in the collection;
each P class code generation method uses information stored in said P class regarding the values needed to initialize constant and variable attributes of said class which gave rise to said P class translation structure to generate source code which implements a P component which functions to store in memory the initialization values of constant and variable attributes of said class when creating an instance of it;
each PL class code generation method uses information stored in said PL class regarding a collection of P components to generate the source code of a PL
component which functions to implement a collection of P components and provides methods to add or get items from said collection and get the number of items in said collection whenever said class which gave rise to said PL class translation structure is a multi-valued component of an aggregation relationship;
each arguments list class code generation method uses information stored in said arguments list class on the arguments of every service of said class to generate an arguments list component;
each analysis class list class code generation method uses information stored in said analysis class list class on the identification function of said class to generate source code of a component that supplies said identification function information to characterize the naming mechanism for instances of said class as they are created;
each of said one or more events classes code generation method uses information stored in said events classes to generate source code components which resolve services in an executive component to implement events, shared events, transactions and object interactions;
each of said one or more auxiliary methods classes code generation methods generate a source code component which implements auxiliary methods needed to resolve a service in both executive components and executive components for inheritance hierarchies so as to implement at least precondition classes, static constraint classes, dynamic constraint classes if preconditions, static constraints and dynamic constraints are present in said Conceptual Model;
each T&Q class code generation method using information stored in said T&Q class to generate source code components that implement queries and T
components; and each inheritance method class code generation method generating source code components to implement methods specific to inheritance relationships specified for said class in said Formal Specification.
each server class instance code generation method uses information stored in said server class instance to generate a server source code component that comprises a method for each service present in the signature of said class;
each global interaction server class code generation method uses information stored in said global interaction server class to generate a source code component that implements global interactions defined in said Conceptual Model with an interface that comprises a method per global interaction defined in said Formal Specification;
each analysis class instance code generation method uses information stored in said analysis class instance to generate a source code component that implements an executive component for the class which yielded said analysis class instance translation structure, said executive component comprising a method per service of the signature of said class which gave rise to said analysis class instance, each method structured to carry out said service according to an execution model;
each global interactions analysis class code generation method uses information stored in said global interactions analysis class to generate a source code component that implements an executive component that provides a method per service implementing global interactions between objects as defined in global transactions specified in said Formal Specification;
each inheritance hierarchy analysis class code generation method uses information stored in said inheritance hierarchy analysis class to generate a source code component that implements an executive component which is part of a group of executive components grouped into a single, special executive component for the inheritance hierarchy;
each query class code generation method uses information stored in said query class to generate a source code component that implements query components which enable a user of said computer program to query the population of said class;
each T class code generation method uses information stored in said T
classregarding the constant and variable attributes of said class which gave rise to said instance of said T class and the methods to calculate the values of derived attributes to generate source code of a T component which provides query access to values of constant and derived attributes and calculates the values of derived attributes of said class;
each C class code generation method uses information stored in said C class regarding the initialization values of constant and variable attributes of said class to generate source code of a C component which functions to populate attributes of said class with said initialization values when creating an instance of said class if said class is a temporal or permanent, condition-based specialization class;
each CC class code generation method uses information stored in said CC
class regarding a temporal or permanent, condition-based specialization defined in said Formal Specification to generate the source code which implement CC
components which implement a collection of C components and provide a pair of methods per C component to add and get items to the collection and a method to get the number of items in the collection;
each P class code generation method uses information stored in said P class regarding the values needed to initialize constant and variable attributes of said class which gave rise to said P class translation structure to generate source code which implements a P component which functions to store in memory the initialization values of constant and variable attributes of said class when creating an instance of it;
each PL class code generation method uses information stored in said PL class regarding a collection of P components to generate the source code of a PL
component which functions to implement a collection of P components and provides methods to add or get items from said collection and get the number of items in said collection whenever said class which gave rise to said PL class translation structure is a multi-valued component of an aggregation relationship;
each arguments list class code generation method uses information stored in said arguments list class on the arguments of every service of said class to generate an arguments list component;
each analysis class list class code generation method uses information stored in said analysis class list class on the identification function of said class to generate source code of a component that supplies said identification function information to characterize the naming mechanism for instances of said class as they are created;
each of said one or more events classes code generation method uses information stored in said events classes to generate source code components which resolve services in an executive component to implement events, shared events, transactions and object interactions;
each of said one or more auxiliary methods classes code generation methods generate a source code component which implements auxiliary methods needed to resolve a service in both executive components and executive components for inheritance hierarchies so as to implement at least precondition classes, static constraint classes, dynamic constraint classes if preconditions, static constraints and dynamic constraints are present in said Conceptual Model;
each T&Q class code generation method using information stored in said T&Q class to generate source code components that implement queries and T
components; and each inheritance method class code generation method generating source code components to implement methods specific to inheritance relationships specified for said class in said Formal Specification.
Applications Claiming Priority (3)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US09/543,085 | 2000-04-04 | ||
US09/543,085 US6681383B1 (en) | 2000-04-04 | 2000-04-04 | Automatic software production system |
CA2403975A CA2403975C (en) | 2000-04-04 | 2001-03-02 | Automatic software production system |
Related Parent Applications (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
CA2403975A Division CA2403975C (en) | 2000-04-04 | 2001-03-02 | Automatic software production system |
Publications (1)
Publication Number | Publication Date |
---|---|
CA2723005A1 true CA2723005A1 (en) | 2001-10-11 |
Family
ID=24166513
Family Applications (2)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
CA2723005A Abandoned CA2723005A1 (en) | 2000-04-04 | 2001-03-02 | Automated software production system |
CA2403975A Expired - Fee Related CA2403975C (en) | 2000-04-04 | 2001-03-02 | Automatic software production system |
Family Applications After (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
CA2403975A Expired - Fee Related CA2403975C (en) | 2000-04-04 | 2001-03-02 | Automatic software production system |
Country Status (6)
Country | Link |
---|---|
US (10) | US6681383B1 (en) |
EP (1) | EP1272927A2 (en) |
JP (3) | JP2004506962A (en) |
AU (2) | AU4194501A (en) |
CA (2) | CA2723005A1 (en) |
WO (1) | WO2001075593A2 (en) |
Cited By (2)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
WO2019113308A1 (en) * | 2017-12-05 | 2019-06-13 | Franchitti Jean Claude | Active adaptation of networked compute devices using vetted reusable software components |
US10552540B2 (en) | 2017-11-27 | 2020-02-04 | International Business Machines Corporation | Automated application composer with natural language processing |
Families Citing this family (789)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US6490594B1 (en) * | 1997-04-04 | 2002-12-03 | Microsoft Corporation | Database computer system with application recovery and dependency handling write cache |
US7210117B2 (en) * | 1999-08-19 | 2007-04-24 | National Instruments Corporation | System and method for programmatically generating a graphical program in response to program information |
US7076400B2 (en) * | 2000-02-14 | 2006-07-11 | Nextnine Ltd. | Support network |
US7409318B2 (en) * | 2000-02-14 | 2008-08-05 | Nextnine Ltd. | Support network |
US7334216B2 (en) * | 2000-04-04 | 2008-02-19 | Sosy, Inc. | Method and apparatus for automatic generation of information system user interfaces |
US6681383B1 (en) * | 2000-04-04 | 2004-01-20 | Sosy, Inc. | Automatic software production system |
US20040231043A1 (en) * | 2000-04-14 | 2004-11-25 | Pop-In Pop-Out, Inc. | Bath lifting system |
US6516322B1 (en) * | 2000-04-28 | 2003-02-04 | Microsoft Corporation | XML-based representation of mobile process calculi |
US7503033B2 (en) * | 2000-04-28 | 2009-03-10 | Microsoft Corporation | Model for business workflow processes |
US7099809B2 (en) * | 2000-05-04 | 2006-08-29 | Dov Dori | Modeling system |
GB2368684A (en) * | 2000-05-31 | 2002-05-08 | Ibm | Managing an object in a management framework |
US7606796B2 (en) * | 2000-06-15 | 2009-10-20 | Generate, Inc. | Method of and system for determining connections between parties using private links |
US20050044148A1 (en) * | 2000-06-29 | 2005-02-24 | Microsoft Corporation | Method and system for accessing multiple types of electronic content |
FR2811093A1 (en) * | 2000-06-30 | 2002-01-04 | St Microelectronics Sa | DEVICE AND METHOD FOR EVALUATING ALGORITHMS |
AUPQ966400A0 (en) * | 2000-08-24 | 2000-09-21 | Xemplex Pty Ltd | Method of graphically defining a formula |
US6820253B1 (en) * | 2000-09-27 | 2004-11-16 | Intel Corporation | Method and system for interprocedural analysis with separate compilation |
US20020087744A1 (en) * | 2000-11-01 | 2002-07-04 | Aeroflex Altair Cybernetics Corporation | Information transformation software engine |
US20030105732A1 (en) * | 2000-11-17 | 2003-06-05 | Kagalwala Raxit A. | Database schema for structure query language (SQL) server |
US7200838B2 (en) * | 2000-12-20 | 2007-04-03 | National Instruments Corporation | System and method for automatically generating a graphical program in response to a state diagram |
US7761270B2 (en) * | 2000-12-29 | 2010-07-20 | Exxonmobil Upstream Research Co. | Computer system and method having a facility management logic architecture |
US7277836B2 (en) * | 2000-12-29 | 2007-10-02 | Exxonmobil Upstream Research Company | Computer system and method having a facility network architecture |
JP3881179B2 (en) * | 2001-02-14 | 2007-02-14 | 三菱電機株式会社 | User interface design device |
US7290243B1 (en) * | 2001-02-28 | 2007-10-30 | Apple Inc. | Method and apparatus for application building using build styles |
GB2373073A (en) * | 2001-03-08 | 2002-09-11 | Escher Technologies Ltd | Process and system for developing validated and optimised object-oriented software |
US7389492B2 (en) * | 2001-03-12 | 2008-06-17 | International Business Machines Corporation | Framework for code generators |
US7406682B2 (en) * | 2001-03-26 | 2008-07-29 | Emc Corporation | Translator-compiler for converting legacy management software |
US20030217333A1 (en) * | 2001-04-16 | 2003-11-20 | Greg Smith | System and method for rules-based web scenarios and campaigns |
US6978442B2 (en) * | 2001-05-03 | 2005-12-20 | International Business Machines Corporation | Auditing data using observable and observer objects |
GB0113946D0 (en) * | 2001-06-08 | 2001-11-14 | Secr Defence | Automatic Development of Software Codes |
US8301503B2 (en) * | 2001-07-17 | 2012-10-30 | Incucomm, Inc. | System and method for providing requested information to thin clients |
CA2704080C (en) | 2001-07-26 | 2012-08-28 | Irise | System and process for cooperatively programming a simulation program of a computer application to be developed |
SE0102648A0 (en) * | 2001-08-02 | 2003-03-06 | Lars Höidahl | Arrangements to perform object-oriented programming |
CA2355418A1 (en) * | 2001-08-16 | 2003-02-16 | Ibm Canada Limited-Ibm Canada Limitee | A schema for sql statements |
US7580871B2 (en) * | 2001-08-31 | 2009-08-25 | Siebel Systems, Inc. | Method to generate a customizable product configurator |
JP2003076543A (en) * | 2001-08-31 | 2003-03-14 | Cats Kk | Device, method for generating program and program for making computer execute the same program |
US7650296B1 (en) * | 2001-08-31 | 2010-01-19 | Siebel Systems, Inc. | Configurator using structure and rules to provide a user interface |
US7386832B2 (en) * | 2001-08-31 | 2008-06-10 | Siebel Systems, Inc. | Configurator using structure to provide a user interface |
GB2379296B (en) * | 2001-09-01 | 2005-05-25 | Ibm | A data storage system having a unified container layer for an active data store |
ATE368900T1 (en) * | 2001-09-21 | 2007-08-15 | Koninkl Kpn Nv | COMPUTER SYSTEM, DATA TRANSMISSION NETWORK, COMPUTER PROGRAM AND DATA CARRIER, ALL FOR FILTERING MESSAGES INCLUDING CONTENT ACCORDING TO A MARKING LANGUAGE |
EP1435058A4 (en) * | 2001-10-11 | 2005-12-07 | Visualsciences Llc | System, method, and computer program product for processing and visualization of information |
US20030093551A1 (en) * | 2001-10-17 | 2003-05-15 | Graham Taylor | Adaptive software interface |
WO2003036464A2 (en) * | 2001-10-22 | 2003-05-01 | Sun Microsystems, Inc. | Inter-process communication using different programming languages |
US6879987B2 (en) * | 2001-10-31 | 2005-04-12 | Inventec Corp. | Method for storing records in database or reading the same therefrom |
US20030103080A1 (en) * | 2001-12-05 | 2003-06-05 | Bahman Radjabi | System and method for developing a code generator for object-oriented communication protocol |
US20030115571A1 (en) * | 2001-12-14 | 2003-06-19 | Telefonaktiebolaget L M Ericsson (Publ) | Construction of a software application from a plurality of programming languages |
US20030117417A1 (en) * | 2001-12-20 | 2003-06-26 | Nortel Networks Limited | Generic application flow management system and method |
US20030140332A1 (en) * | 2001-12-21 | 2003-07-24 | Norton Jeffrey B. | Method and apparatus for generating a software development tool |
US7188335B1 (en) * | 2001-12-28 | 2007-03-06 | Trilogy Development Group, Inc. | Product configuration using configuration patterns |
US20050144175A1 (en) * | 2002-02-18 | 2005-06-30 | Siemens Aktiengesellschaft | Method and system for administrating use of a service |
US7363612B2 (en) * | 2002-03-06 | 2008-04-22 | Sun Microsystems, Inc. | Application programs with dynamic components |
US6760640B2 (en) | 2002-03-14 | 2004-07-06 | Photronics, Inc. | Automated manufacturing system and method for processing photomasks |
US6842881B2 (en) * | 2002-07-30 | 2005-01-11 | Photronics, Inc. | Rule based system and method for automatically generating photomask orders in a specified order format |
US7640529B2 (en) * | 2002-07-30 | 2009-12-29 | Photronics, Inc. | User-friendly rule-based system and method for automatically generating photomask orders |
US7669167B2 (en) * | 2002-07-30 | 2010-02-23 | Photronics, Inc. | Rule based system and method for automatically generating photomask orders by conditioning information from a customer's computer system |
US20030182458A1 (en) * | 2002-03-22 | 2003-09-25 | Ali Syed M. | Generating a decoupled presentation layer in an application |
US7287229B2 (en) * | 2002-04-03 | 2007-10-23 | Hewlett-Packard Development Company, L.P. | Template-driven process system |
AU2003243146A1 (en) * | 2002-04-19 | 2003-11-03 | Computer Associates Think, Inc. | System and method for client-side locale specific numeric format handling in a web environment |
BR0309333A (en) * | 2002-04-19 | 2007-02-21 | Computer Ass Think Inc | system and method for providing inference services |
US6804686B1 (en) * | 2002-04-29 | 2004-10-12 | Borland Software Corporation | System and methodology for providing fixed UML layout for an object oriented class browser |
US7725560B2 (en) | 2002-05-01 | 2010-05-25 | Bea Systems Inc. | Web service-enabled portlet wizard |
WO2003093964A1 (en) * | 2002-05-01 | 2003-11-13 | Bea Systems, Inc. | Enterprise application platform |
US7127467B2 (en) | 2002-05-10 | 2006-10-24 | Oracle International Corporation | Managing expressions in a database system |
US7107280B2 (en) * | 2002-05-14 | 2006-09-12 | Haestad Methods, Inc. | Method and system for the storage and use of engineering modeling alternatives with unitized data |
US7640548B1 (en) | 2002-06-21 | 2009-12-29 | Siebel Systems, Inc. | Task based user interface |
US7426521B2 (en) * | 2002-07-19 | 2008-09-16 | Microsoft Corporation | Property and object validation in a database system |
EP1387261A1 (en) * | 2002-07-30 | 2004-02-04 | Sereneo | Application software generation and language for software description |
US7237014B2 (en) * | 2002-08-01 | 2007-06-26 | Drummond Group | System and method for in situ, real-time, supply chain, interoperability verification |
US20040031017A1 (en) * | 2002-08-12 | 2004-02-12 | Shankar Vaidyanathan | System and method for context-sensitive help in a design environment |
US7219328B2 (en) * | 2002-08-28 | 2007-05-15 | Honeywell International Inc. | Model-based composable code generation |
EP1532522A2 (en) * | 2002-08-29 | 2005-05-25 | Crossmarx B.V. | System and method for executing and building a software application |
WO2004025463A1 (en) * | 2002-09-09 | 2004-03-25 | Catena Corporation | Requirement defining method, method for developing software, method for changing requirement word, and newly defining method |
US7383513B2 (en) * | 2002-09-25 | 2008-06-03 | Oracle International Corporation | Graphical condition builder for facilitating database queries |
WO2004031937A1 (en) * | 2002-09-30 | 2004-04-15 | Microsoft Corporation | System and method for making user interface elements known to an application and user |
US7114148B2 (en) * | 2002-09-30 | 2006-09-26 | Microsoft Corporation | Runtime services for network software platform |
US8832178B2 (en) | 2002-11-06 | 2014-09-09 | Noel William Lovisa | Service implementation |
US7412658B2 (en) * | 2002-11-14 | 2008-08-12 | Sap Ag | Modeling system for graphic user interface |
US7149752B2 (en) * | 2002-12-03 | 2006-12-12 | Jp Morgan Chase Bank | Method for simplifying databinding in application programs |
US7191431B2 (en) * | 2002-12-20 | 2007-03-13 | International Business Machines Corporation | System and method for selecting a translator to translate a component request using semantic typing |
US7117449B1 (en) * | 2002-12-31 | 2006-10-03 | Siebel Systems, Inc. | Method and apparatus to present an integrated process modeler |
US8032439B2 (en) * | 2003-01-07 | 2011-10-04 | Jpmorgan Chase Bank, N.A. | System and method for process scheduling |
US7401156B2 (en) * | 2003-02-03 | 2008-07-15 | Jp Morgan Chase Bank | Method using control interface to suspend software network environment running on network devices for loading and executing another software network environment |
US8831966B2 (en) | 2003-02-14 | 2014-09-09 | Oracle International Corporation | Method for delegated administration |
US7591000B2 (en) | 2003-02-14 | 2009-09-15 | Oracle International Corporation | System and method for hierarchical role-based entitlements |
US7653930B2 (en) | 2003-02-14 | 2010-01-26 | Bea Systems, Inc. | Method for role and resource policy management optimization |
US7293286B2 (en) | 2003-02-20 | 2007-11-06 | Bea Systems, Inc. | Federated management of content repositories |
US7840614B2 (en) | 2003-02-20 | 2010-11-23 | Bea Systems, Inc. | Virtual content repository application program interface |
US7415478B2 (en) * | 2003-02-20 | 2008-08-19 | Bea Systems, Inc. | Virtual repository complex content model |
US7810036B2 (en) | 2003-02-28 | 2010-10-05 | Bea Systems, Inc. | Systems and methods for personalizing a portal |
US7313754B2 (en) * | 2003-03-14 | 2007-12-25 | Texterity, Inc. | Method and expert system for deducing document structure in document conversion |
US7379998B2 (en) * | 2003-03-31 | 2008-05-27 | Jp Morgan Chase Bank | System and method for multi-platform queue queries |
US7114146B2 (en) * | 2003-05-02 | 2006-09-26 | International Business Machines Corporation | System and method of dynamic service composition for business process outsourcing |
US20040230602A1 (en) * | 2003-05-14 | 2004-11-18 | Andrew Doddington | System and method for decoupling data presentation layer and data gathering and storage layer in a distributed data processing system |
US7366722B2 (en) * | 2003-05-15 | 2008-04-29 | Jp Morgan Chase Bank | System and method for specifying application services and distributing them across multiple processors using XML |
US7509641B2 (en) * | 2003-05-16 | 2009-03-24 | Jp Morgan Chase Bank | Job processing framework |
US8239833B2 (en) * | 2003-06-26 | 2012-08-07 | Stmicroelectronics S.A. | Statistical control of the integrity of a program |
AU2004254999A1 (en) * | 2003-06-27 | 2005-01-13 | Generate, Inc. | Method of and system for determining connections between parties using private links |
US20050197998A1 (en) * | 2003-07-11 | 2005-09-08 | Asbury Mark R. | Dynamic database SQL script execution through JDBC |
US8219968B2 (en) * | 2003-07-17 | 2012-07-10 | Raytheon Company | Designing computer programs |
US7519952B2 (en) * | 2003-07-28 | 2009-04-14 | International Business Machines Corporation | Detecting an integrity constraint violation in a database by analyzing database schema, application and mapping and inserting a check into the database and application |
US7840943B2 (en) * | 2003-08-08 | 2010-11-23 | Oracle America, Inc. | Method and apparatus for transferring data in a distributed testing system |
US20050065970A1 (en) * | 2003-08-20 | 2005-03-24 | King Anthony Graham | System, method and apparatus for developing software |
US7237224B1 (en) | 2003-08-28 | 2007-06-26 | Ricoh Company Ltd. | Data structure used for skeleton function of a class in a skeleton code creation tool |
US7793257B2 (en) * | 2003-08-28 | 2010-09-07 | Ricoh Company, Ltd. | Technique for automating code generation in developing software systems |
US7308675B2 (en) * | 2003-08-28 | 2007-12-11 | Ricoh Company, Ltd. | Data structure used for directory structure navigation in a skeleton code creation tool |
US20050060188A1 (en) * | 2003-09-03 | 2005-03-17 | Electronic Data Systems Corporation | System, method, and computer program product for health care patient and service management |
US7822795B2 (en) * | 2003-09-19 | 2010-10-26 | Lattix, Inc. | Apparatus and methods for displaying and determining dependency relationships among subsystems in a computer software system |
US7356802B2 (en) * | 2003-09-29 | 2008-04-08 | International Business Machines Corporation | Automatic customization of classes |
US7870504B1 (en) | 2003-10-01 | 2011-01-11 | TestPlant Inc. | Method for monitoring a graphical user interface on a second computer display from a first computer |
US20050257245A1 (en) * | 2003-10-10 | 2005-11-17 | Bea Systems, Inc. | Distributed security system with dynamic roles |
US20050251852A1 (en) * | 2003-10-10 | 2005-11-10 | Bea Systems, Inc. | Distributed enterprise security system |
US20050081166A1 (en) * | 2003-10-14 | 2005-04-14 | Stokke Michael A. | System and method facilitating automated navigation for user interface(s) |
US8024705B2 (en) * | 2003-11-12 | 2011-09-20 | Siemens Product Lifecycle Management Software Inc. | System, method, and computer program product for distributed testing of program code |
US7325227B2 (en) * | 2003-11-12 | 2008-01-29 | Siemens Product Lifecycle Management Software | System, method, and computer program product for identifying code development errors |
US8799001B2 (en) * | 2003-11-17 | 2014-08-05 | Nuance Communications, Inc. | Method and system for defining standard catch styles for speech application code generation |
US20050114841A1 (en) * | 2003-11-21 | 2005-05-26 | Moskowitz Milton E. | Automatic computer code review tool |
US20050154742A1 (en) * | 2003-11-26 | 2005-07-14 | Aviv Roth | Business software application generation system and method |
US8381207B2 (en) | 2003-12-02 | 2013-02-19 | International Business Machines Corporation | Script generation engine and mapping semantic models for target platform |
US9489687B2 (en) * | 2003-12-04 | 2016-11-08 | Black Duck Software, Inc. | Methods and systems for managing software development |
US8700533B2 (en) * | 2003-12-04 | 2014-04-15 | Black Duck Software, Inc. | Authenticating licenses for legally-protectable content based on license profiles and content identifiers |
US7752559B1 (en) * | 2003-12-05 | 2010-07-06 | The Mathworks, Inc. | Graphical model preparation for embedded deployment |
US7711753B2 (en) * | 2003-12-08 | 2010-05-04 | Oracle International Corporation | Systems and methods for validating design meta-data |
US7865480B2 (en) * | 2003-12-08 | 2011-01-04 | Oracle International Corporation | Systems and methods for validating objects models |
US7844640B2 (en) * | 2003-12-17 | 2010-11-30 | Sap Ag | Data mapping visualization |
AU2003291794A1 (en) * | 2003-12-18 | 2005-07-05 | Motorola Inc | A method of automatically generating test scripts from a system specification model |
US7930149B2 (en) | 2003-12-19 | 2011-04-19 | Sap Aktiengesellschaft | Versioning of elements in a configuration model |
FR2864280A1 (en) * | 2003-12-19 | 2005-06-24 | Thales Sa | Documentary transfer chain creating method, involves establishing dynamic link for each document fragment, between its location in documentary transfer chain and its physical file issued from automatic document generator |
US20070074180A1 (en) * | 2003-12-22 | 2007-03-29 | Nasa Hq's | Systems, Methods and Apparatus for Procedure Development and Verification |
US7752608B1 (en) * | 2003-12-22 | 2010-07-06 | The United States Of America As Represented By The Administrator Of The National Aeronautics And Space Administration | Systems, methods and apparatus for verification of knowledge-based systems |
US7739671B1 (en) | 2003-12-22 | 2010-06-15 | The United States Of America As Represented By The Administrator Of The National Aeronautics And Space Administration | Systems, methods and apparatus for implementation of formal specifications derived from informal requirements |
US7712073B1 (en) * | 2003-12-23 | 2010-05-04 | Sprint Communications Company L.P. | Software development artifact creation tool |
JP2005196291A (en) * | 2003-12-26 | 2005-07-21 | Fujitsu Ltd | User interface application development program and development device |
US20050144174A1 (en) * | 2003-12-31 | 2005-06-30 | Leonid Pesenson | Framework for providing remote processing of a graphical user interface |
GB2410577A (en) * | 2004-01-31 | 2005-08-03 | Patrick Ian Carmody | Development and maintenance of computer databases |
US7533365B1 (en) * | 2004-02-03 | 2009-05-12 | Borland Software Corporation | Development system with methodology for run-time restoration of UML model from program code |
US8112383B2 (en) * | 2004-02-10 | 2012-02-07 | Microsoft Corporation | Systems and methods for a database engine in-process data provider |
US6876314B1 (en) | 2004-02-18 | 2005-04-05 | Robocoder Corporation | Self-generating automatic code generator |
US8135755B2 (en) * | 2005-06-29 | 2012-03-13 | Microsoft Corporation | Templates in a schema editor |
US7788078B1 (en) | 2004-02-27 | 2010-08-31 | Synopsys, Inc. | Processor/memory co-exploration at multiple abstraction levels |
US7640251B2 (en) * | 2004-03-15 | 2009-12-29 | Rameo Systems Limited | Structured approach to software specification |
US7657542B2 (en) * | 2004-03-15 | 2010-02-02 | Ramco Systems Limited | Software life cycle availability over the internet |
US7793258B2 (en) * | 2004-03-15 | 2010-09-07 | Ramco Systems Limited | Software development using visual interfaces |
US20050204334A1 (en) * | 2004-03-15 | 2005-09-15 | Ramco Systems Limited | Component based software system |
US9009658B2 (en) * | 2004-03-15 | 2015-04-14 | Ramco Systems Limited | Component based software system |
US20050216884A1 (en) * | 2004-03-25 | 2005-09-29 | Microsoft Corporation | Object generation |
US8677312B1 (en) | 2004-03-30 | 2014-03-18 | Synopsys, Inc. | Generation of compiler description from architecture description |
US8689202B1 (en) | 2004-03-30 | 2014-04-01 | Synopsys, Inc. | Scheduling of instructions |
US7774601B2 (en) | 2004-04-06 | 2010-08-10 | Bea Systems, Inc. | Method for delegated administration |
US9734222B1 (en) | 2004-04-06 | 2017-08-15 | Jpmorgan Chase Bank, N.A. | Methods and systems for using script files to obtain, format and transport data |
US20050222990A1 (en) * | 2004-04-06 | 2005-10-06 | Milne Kenneth T | Methods and systems for using script files to obtain, format and disseminate database information |
US20050229152A1 (en) * | 2004-04-08 | 2005-10-13 | Brian Connell | Integrated modeling environment |
US20050251512A1 (en) * | 2004-04-13 | 2005-11-10 | Bea Systems, Inc. | System and method for searching a virtual content repository |
US20060041558A1 (en) * | 2004-04-13 | 2006-02-23 | Mccauley Rodney | System and method for content versioning |
US20060028252A1 (en) * | 2004-04-13 | 2006-02-09 | Bea Systems, Inc. | System and method for content type management |
US7246138B2 (en) * | 2004-04-13 | 2007-07-17 | Bea Systems, Inc. | System and method for content lifecycles in a virtual content repository that integrates a plurality of content repositories |
US7590969B2 (en) * | 2004-04-14 | 2009-09-15 | Microsoft Corporation | Type system |
US7797676B2 (en) * | 2004-04-20 | 2010-09-14 | International Business Machines Corporation | Method and system for switching between prototype and real code production in a graphical call flow builder |
US7376830B2 (en) * | 2004-04-26 | 2008-05-20 | Jp Morgan Chase Bank | System and method for routing messages |
GB0410047D0 (en) * | 2004-05-05 | 2004-06-09 | Silverdata Ltd | An analytical software design system |
DE102004023634B4 (en) * | 2004-05-10 | 2007-09-27 | Siemens Ag | Method for checking the completeness and consistency of an information library |
US20050257154A1 (en) * | 2004-05-14 | 2005-11-17 | Bea Systems, Inc. | Graphical association of elements for portal and webserver administration |
JP4100630B2 (en) * | 2004-05-14 | 2008-06-11 | インターナショナル・ビジネス・マシーンズ・コーポレーション | UML design method |
US20050257172A1 (en) * | 2004-05-14 | 2005-11-17 | Bea Systems, Inc. | Interface for filtering for portal and webserver administration |
US20050256899A1 (en) * | 2004-05-14 | 2005-11-17 | Bea Systems, Inc. | System and method for representing hierarchical data structures |
US20050256906A1 (en) * | 2004-05-14 | 2005-11-17 | Bea Systems, Inc. | Interface for portal and webserver administration-efficient updates |
EP2386946B1 (en) * | 2004-05-20 | 2020-06-10 | Code Valley Corp Pty Ltd | Code generation techniques using components in a distributed system |
US7343379B2 (en) * | 2004-05-21 | 2008-03-11 | Bea Systems, Inc. | System and method for controls |
US7607126B2 (en) * | 2004-05-21 | 2009-10-20 | Bea Systems, Inc. | System and method for external override of annotations |
US7451433B2 (en) | 2004-05-21 | 2008-11-11 | Bea Systems, Inc. | System and method for descriptor classes |
US9280326B1 (en) | 2004-05-26 | 2016-03-08 | Synopsys, Inc. | Compiler retargeting based on instruction semantic models |
US8458060B2 (en) * | 2004-05-28 | 2013-06-04 | Vendavo, Inc. | System and method for organizing price modeling data using hierarchically organized portfolios |
US20060004861A1 (en) * | 2004-05-28 | 2006-01-05 | Albanese Michael J | System and method for displaying price modeling data |
US20050278227A1 (en) * | 2004-05-28 | 2005-12-15 | Niel Esary | Systems and methods of managing price modeling data through closed-loop analytics |
US8006225B1 (en) * | 2004-06-03 | 2011-08-23 | Synposys, Inc. | Method and system for automatic generation of instruction-set documentation from an abstract processor model described using a hierarchical architectural description language |
US7730482B2 (en) * | 2004-06-08 | 2010-06-01 | Covia Labs, Inc. | Method and system for customized programmatic dynamic creation of interoperability content |
US7360209B2 (en) * | 2004-07-16 | 2008-04-15 | Graphlogic Inc. | Object process graph application controller-viewer |
US8473893B2 (en) * | 2008-09-30 | 2013-06-25 | Accurev, Inc. | Integration of external software analysis processes with software configuration management applications |
US8341590B1 (en) | 2007-12-12 | 2012-12-25 | Accurev, Inc. | System for relating workflow status to code component status in a software project |
US8667465B2 (en) * | 2008-03-31 | 2014-03-04 | Accurev, Inc. | System for estimating a software product release time from version information |
US8548967B1 (en) * | 2007-12-12 | 2013-10-01 | Accurev, Inc. | System for visual query and manipulation of configuration management records |
US9292276B1 (en) | 2004-07-19 | 2016-03-22 | Micro Focus (IP) Development Limited | Method and system for utilizing change packages |
US20060031819A1 (en) * | 2004-08-06 | 2006-02-09 | Microsoft Corporation | Methods and apparatus for creating solutions |
US7698291B2 (en) * | 2004-08-26 | 2010-04-13 | Sap Ag | Method and system for integrating user-defined objects into a business management application |
US8051408B1 (en) * | 2004-09-13 | 2011-11-01 | The Mathworks, Inc. | Method of providing interactive usage descriptions based on source code analysis |
US20060059459A1 (en) * | 2004-09-13 | 2006-03-16 | Microsoft Corporation | Generating solution-based software documentation |
US7376933B2 (en) * | 2004-10-22 | 2008-05-20 | International Business Machines Corporation | System and method for creating application content using an open model driven architecture |
US8024703B2 (en) * | 2004-10-22 | 2011-09-20 | International Business Machines Corporation | Building an open model driven architecture pattern based on exemplars |
US20060101385A1 (en) * | 2004-10-22 | 2006-05-11 | Gerken Christopher H | Method and System for Enabling Roundtrip Code Protection in an Application Generator |
US20060101387A1 (en) * | 2004-10-22 | 2006-05-11 | Gerken Christopher H | An Open Model Driven Architecture Application Implementation Service |
US7783670B2 (en) * | 2004-11-18 | 2010-08-24 | Bea Systems, Inc. | Client server conversion for representing hierarchical data structures |
US7689999B2 (en) | 2004-12-01 | 2010-03-30 | Bea Systems, Inc. | Sharing dynamically changing resources in software systems |
US20060122724A1 (en) * | 2004-12-07 | 2006-06-08 | Photoronics, Inc. 15 Secor Road P.O. Box 5226 Brookfield, Connecticut 06804 | System and method for automatically generating a tooling specification using a logical operations utility that can be used to generate a photomask order |
US7627866B2 (en) | 2004-12-15 | 2009-12-01 | Bea Systems, Inc. | Systems and methods for dynamic application patching |
EP1674957A1 (en) * | 2004-12-21 | 2006-06-28 | Siemens Aktiengesellschaft | Rule based, distributed engineering |
US7814427B2 (en) * | 2005-01-05 | 2010-10-12 | Microsoft Corporation | Object model tree diagram |
US7774787B2 (en) * | 2005-01-11 | 2010-08-10 | Microsoft Corporation | Method for specifying and verifying multi-threaded object-oriented programs with invariants |
US7814457B2 (en) * | 2005-01-19 | 2010-10-12 | Sap Ag | System and method for revising flow diagrams displaying a process |
US7853931B2 (en) * | 2005-01-19 | 2010-12-14 | Sap Ag | System and method for automatically generating flow diagrams |
US7610576B2 (en) * | 2005-01-19 | 2009-10-27 | Sap Ag | System and method for simultaneous display of processes and associated files |
US8225283B2 (en) * | 2005-01-31 | 2012-07-17 | International Business Machines Corporation | Method and apparatus for enabling collaborative product development processes |
US7793255B1 (en) * | 2005-03-01 | 2010-09-07 | Oracle America, Inc. | System and method for maintaining alternate object views |
US7567975B2 (en) * | 2005-03-16 | 2009-07-28 | Oracle International Corporation | Incremental evaluation of complex event-condition-action rules in a database system |
US9129226B2 (en) * | 2011-12-04 | 2015-09-08 | Beyondcore, Inc. | Analyzing data sets with the help of inexpert humans to find patterns |
US10127130B2 (en) | 2005-03-18 | 2018-11-13 | Salesforce.Com | Identifying contributors that explain differences between a data set and a subset of the data set |
US20060230389A1 (en) * | 2005-04-12 | 2006-10-12 | Moulckers Ingrid M | System and method for specifying business requirements for dynamically generated runtime solution to a business problem |
US20060229894A1 (en) * | 2005-04-12 | 2006-10-12 | Moulckers Ingrid M | System and method for estimating expense and return on investment of a dynamically generated runtime solution to a business problem |
EP1615125A1 (en) * | 2005-04-14 | 2006-01-11 | Agilent Technologies, Inc. | Automatic source code generation |
US7590978B2 (en) * | 2005-04-15 | 2009-09-15 | Microsoft Corporation | Inferring object invariant method and system |
US7559054B2 (en) * | 2005-04-19 | 2009-07-07 | Microsoft Corporation | Abstract interpretation with a congruence abstract domain and/or a heap succession abstract domain |
US20060242194A1 (en) * | 2005-04-22 | 2006-10-26 | Igor Tsyganskiy | Systems and methods for modeling and manipulating a table-driven business application in an object-oriented environment |
US20060242171A1 (en) * | 2005-04-22 | 2006-10-26 | Igor Tsyganskiy | Methods of using code-based case tools to verify application layer configurations |
US8539003B2 (en) * | 2005-04-22 | 2013-09-17 | Sap Ag | Systems and methods for identifying problems of a business application in a customer support system |
US20060242197A1 (en) * | 2005-04-22 | 2006-10-26 | Igor Tsyganskiy | Methods of transforming application layer structure as objects |
US7958486B2 (en) * | 2005-04-22 | 2011-06-07 | Sap Ag | Methods and systems for data-focused debugging and tracing capabilities |
US7542980B2 (en) * | 2005-04-22 | 2009-06-02 | Sap Ag | Methods of comparing and merging business process configurations |
US20060242174A1 (en) * | 2005-04-22 | 2006-10-26 | Igor Tsyganskiy | Systems and methods for using object-oriented tools to debug business applications |
US20060242177A1 (en) * | 2005-04-22 | 2006-10-26 | Igor Tsyganskiy | Methods of exposing business application runtime exceptions at design time |
US7702638B2 (en) * | 2005-04-22 | 2010-04-20 | Sap Ag | Systems and methods for off-line modeling a business application |
US20060241961A1 (en) * | 2005-04-22 | 2006-10-26 | Igor Tsyganskiy | Methods of optimizing legacy application layer control structure using refactoring |
US20060293935A1 (en) * | 2005-04-22 | 2006-12-28 | Igor Tsyganskiy | Methods and systems for incrementally exposing business application errors using an integrated display |
US20060242188A1 (en) * | 2005-04-22 | 2006-10-26 | Igor Tsyganskiy | Methods of exposing a missing collection of application elements as deprecated |
US20060293934A1 (en) * | 2005-04-22 | 2006-12-28 | Igor Tsyganskiy | Methods and systems for providing an integrated business application configuration environment |
JP4855710B2 (en) * | 2005-04-28 | 2012-01-18 | 株式会社東芝 | Software plug-in method and application program |
US7886273B2 (en) * | 2005-04-29 | 2011-02-08 | The United States Of America As Represented By The Administrator Of The National Aeronautics And Space Administration | Systems, methods and apparatus for generation and verification of policies in autonomic computing systems |
EP1734442A1 (en) * | 2005-05-19 | 2006-12-20 | Agilent Technologies, Inc. | Modular code generation |
US7634766B2 (en) * | 2005-05-20 | 2009-12-15 | Sun Microsystems, Inc. | Method and apparatus for pattern-based system design analysis using a meta model |
US7703074B2 (en) * | 2005-05-20 | 2010-04-20 | Oracle America, Inc. | Method and apparatus for tracking changes in a system |
US20060265700A1 (en) * | 2005-05-20 | 2006-11-23 | Sun Microsystems, Inc. | Method and apparatus for pattern-based system design analysis |
US7660802B2 (en) * | 2005-05-20 | 2010-02-09 | Sun Microsystems, Inc. | Method and apparatus for generating components for pattern-based system design analysis using a characteristics model |
US20060265697A1 (en) * | 2005-05-20 | 2006-11-23 | Sun Microsystems, Inc. | Pattern query language |
US7571434B1 (en) | 2005-05-20 | 2009-08-04 | Sun Microsystems, Inc. | Method and apparatus for transparent invocation of a characteristics extractor for pattern-based system design analysis |
US7653898B1 (en) | 2005-05-20 | 2010-01-26 | Sun Microsystems, Inc. | Method and apparatus for generating a characteristics model for a pattern-based system design analysis using a schema |
US20060277525A1 (en) * | 2005-06-06 | 2006-12-07 | Microsoft Corporation | Lexical, grammatical, and semantic inference mechanisms |
FR2887349B1 (en) * | 2005-06-21 | 2008-04-04 | Alcatel Sa | DATA PROCESSING METHOD COMPATIBLE WITH FORMALISM FOR MODELING OBJECTS |
CN101203862B (en) * | 2005-06-28 | 2011-03-23 | 埃克森美孚上游研究公司 | High-level graphical programming language and tool for oil well management programming |
US7437341B2 (en) * | 2005-06-29 | 2008-10-14 | American Express Travel Related Services Company, Inc. | System and method for selecting a suitable technical architecture to implement a proposed solution |
WO2008121098A1 (en) * | 2005-06-29 | 2008-10-09 | Sue Kunz | Software digital fingerprint |
US7480673B2 (en) * | 2005-07-06 | 2009-01-20 | International Business Machines Corporation | Optimized computer diagramming method |
US20070022405A1 (en) * | 2005-07-20 | 2007-01-25 | Caterpillar Inc. | Method and system for software design |
US8250226B2 (en) * | 2005-07-21 | 2012-08-21 | Ca, Inc. | Generating one or more clients for generating one or more synthetic transactions with one or more web service operations |
US20070027905A1 (en) * | 2005-07-29 | 2007-02-01 | Microsoft Corporation | Intelligent SQL generation for persistent object retrieval |
US7979472B2 (en) * | 2005-07-29 | 2011-07-12 | Sap Ag | Method for conditionally branching a validation |
US7870162B2 (en) * | 2005-07-29 | 2011-01-11 | Sap Ag | Method for generating properly formed expressions |
US20070027849A1 (en) * | 2005-07-29 | 2007-02-01 | Microsoft Corporation | Integrating query-related operators in a programming language |
US20070044083A1 (en) * | 2005-07-29 | 2007-02-22 | Microsoft Corporation | Lambda expressions |
US7702686B2 (en) * | 2005-07-29 | 2010-04-20 | Microsoft Corporation | Retrieving and persisting objects from/to relational databases |
US7685567B2 (en) * | 2005-07-29 | 2010-03-23 | Microsoft Corporation | Architecture that extends types using extension methods |
US7631011B2 (en) * | 2005-07-29 | 2009-12-08 | Microsoft Corporation | Code generation patterns |
US7752606B2 (en) * | 2005-08-10 | 2010-07-06 | Capital One Financial Corporation | Software development tool using a structured format to generate software code |
US8667395B2 (en) * | 2005-08-19 | 2014-03-04 | Nintendo Co., Ltd. | Method and apparatus for creating video game and entertainment demonstrations with full preview and/or other features |
US8196104B2 (en) * | 2005-08-31 | 2012-06-05 | Sap Ag | Systems and methods for testing application accessibility |
JP2007079954A (en) * | 2005-09-14 | 2007-03-29 | Sony Corp | Information processing method and device, recording medium and program |
US8719716B2 (en) | 2005-09-15 | 2014-05-06 | The Mathworks, Inc. | Locked element for use in a graphical modeling environment |
US20070067341A1 (en) * | 2005-09-20 | 2007-03-22 | International Business Machines Corporation | Automated user interface functional requirements tool |
US7752205B2 (en) | 2005-09-26 | 2010-07-06 | Bea Systems, Inc. | Method and system for interacting with a virtual content repository |
US7818344B2 (en) | 2005-09-26 | 2010-10-19 | Bea Systems, Inc. | System and method for providing nested types for content management |
US7917537B2 (en) | 2005-09-26 | 2011-03-29 | Oracle International Corporation | System and method for providing link property types for content management |
US7953734B2 (en) | 2005-09-26 | 2011-05-31 | Oracle International Corporation | System and method for providing SPI extensions for content management system |
JP4783612B2 (en) * | 2005-10-12 | 2011-09-28 | 富士通セミコンダクター株式会社 | Extended language specification designation method, program development method, program, and computer-readable storage medium |
US8930889B2 (en) * | 2005-11-17 | 2015-01-06 | The United States Of America, As Represented By The Secretary Of The Navy | Software modeling system and method |
US8397209B2 (en) * | 2005-11-17 | 2013-03-12 | The Government Of The United States Of America, As Represented By The Secretary Of The Navy | Software modeling system and method |
US20090125892A1 (en) * | 2005-11-18 | 2009-05-14 | Robert Arthur Crewdson | Computer Software Development System and Method |
AU2006315078B2 (en) * | 2005-11-18 | 2012-02-16 | Robert Arthur Crewdson | Computer software development system and method |
US8176468B2 (en) | 2005-12-01 | 2012-05-08 | Cypress Semiconductor Corporation | Multivariable transfer functions |
US7716639B2 (en) * | 2005-12-15 | 2010-05-11 | Abb Technology Ltd. | Specification wizard |
US20070143307A1 (en) * | 2005-12-15 | 2007-06-21 | Bowers Matthew N | Communication system employing a context engine |
US8464210B1 (en) * | 2005-12-22 | 2013-06-11 | Rockstar Consortium Us Lp | Software development and testing environment |
JP2007179165A (en) * | 2005-12-27 | 2007-07-12 | Internatl Business Mach Corp <Ibm> | Computer program and method for deriving stochastic performance evaluation model from ulm design model |
US7757204B2 (en) * | 2005-12-29 | 2010-07-13 | Sap Ag | Limiting extensibility of a visual modeling language |
US8983823B1 (en) * | 2005-12-29 | 2015-03-17 | The Mathworks, Inc. | Verification harness for automatically generating a text-based representation of a graphical model |
US8316344B2 (en) | 2005-12-30 | 2012-11-20 | Sap Ag | Software model deployment units |
US8402426B2 (en) | 2005-12-30 | 2013-03-19 | Sap Ag | Architectural design for make to stock application software |
US8522194B2 (en) | 2005-12-30 | 2013-08-27 | Sap Ag | Software modeling |
US8396731B2 (en) | 2005-12-30 | 2013-03-12 | Sap Ag | Architectural design for service procurement application software |
US8448137B2 (en) * | 2005-12-30 | 2013-05-21 | Sap Ag | Software model integration scenarios |
US8380553B2 (en) | 2005-12-30 | 2013-02-19 | Sap Ag | Architectural design for plan-driven procurement application software |
US7882486B2 (en) * | 2006-02-10 | 2011-02-01 | Microsoft Corporation | Adding interactivity to artwork |
US20120124550A1 (en) * | 2006-02-22 | 2012-05-17 | Robert Nocera | Facilitating database application code translation from a first application language to a second application language |
US8490048B2 (en) * | 2006-03-17 | 2013-07-16 | International Business Machines Corporation | Apparatus, system, and method for tool-based creation of a hub server/application interface |
US7415448B2 (en) * | 2006-03-20 | 2008-08-19 | Microsoft Corporation | Adaptive engine for processing geographic data |
US8442850B2 (en) | 2006-03-30 | 2013-05-14 | Sap Ag | Providing accounting software application as enterprise services |
US20070240128A1 (en) * | 2006-04-07 | 2007-10-11 | Patton Richard D | Systems and methods for generating a user interface using a domain specific language |
US7934193B2 (en) * | 2006-04-11 | 2011-04-26 | Rojer Alan S | Processing a module specification to produce a module definition |
US7962888B2 (en) * | 2006-04-11 | 2011-06-14 | Rojer Alan S | Producing unitary class definitions from module specifications |
US8091069B2 (en) * | 2006-04-11 | 2012-01-03 | Rojer Alan S | Module specification language and meta-module |
US20070244691A1 (en) * | 2006-04-17 | 2007-10-18 | Microsoft Corporation | Translation of user interface text strings |
US7784022B2 (en) * | 2006-04-25 | 2010-08-24 | Sap Ag | Mapping a new user interface onto an existing integrated interface |
US20070282719A1 (en) * | 2006-04-27 | 2007-12-06 | Zemah Haim | Platform generator for processing financial activities and management thereof |
US20080126264A1 (en) * | 2006-05-02 | 2008-05-29 | Tellefsen Jens E | Systems and methods for price optimization using business segmentation |
US8234630B2 (en) * | 2006-05-03 | 2012-07-31 | The Mathworks, Inc. | Calling an entity of a graphical model with a non-graphical entity and calling a non-graphical entity of a graphical model with a graphical entity |
JP2007304998A (en) * | 2006-05-12 | 2007-11-22 | Hitachi Software Eng Co Ltd | Source code generation method, device, and program |
WO2008143660A1 (en) * | 2006-05-12 | 2008-11-27 | Iosemantics, Llc | Generating and utilizing finite input output models, comparison of semantic models and software quality assurance |
WO2007133748A2 (en) * | 2006-05-15 | 2007-11-22 | Vendavo, Inc. | Systems and methods for price setting and triangulation |
JP2007328692A (en) * | 2006-06-09 | 2007-12-20 | Canon Inc | Algebra operation method and device therefor, and program |
US8006226B2 (en) * | 2006-06-09 | 2011-08-23 | Sorriso Technologies Inc. | Methods and apparatus for generating a web site from a use case |
US7844942B2 (en) * | 2006-06-12 | 2010-11-30 | International Business Machines Corporation | System and method for model driven transformation filtering |
US7610172B2 (en) * | 2006-06-16 | 2009-10-27 | Jpmorgan Chase Bank, N.A. | Method and system for monitoring non-occurring events |
US8024235B2 (en) * | 2006-06-21 | 2011-09-20 | Microsoft Corporation | Automatic search functionality within business applications |
CN101093493B (en) * | 2006-06-23 | 2011-08-31 | 国际商业机器公司 | Speech conversion method for database inquiry and converter |
US8522261B2 (en) * | 2006-06-30 | 2013-08-27 | Sap Ag | Using status models with state guards in a computer system |
WO2008000878A2 (en) * | 2006-06-30 | 2008-01-03 | Business Excellence Through Information Technologies, S.L. | Electronic commerce system for the purchase of custom-developed computer applications for managing information using structured data models. |
US8200715B1 (en) | 2006-06-30 | 2012-06-12 | Sap Ag | Using status models with adaptable process steps in a computer system |
US8365200B1 (en) | 2006-06-30 | 2013-01-29 | Sap Ag | Using cancellation status models in a computer system |
US8706776B1 (en) | 2006-06-30 | 2014-04-22 | Sap Ag | Extending status models in a computer system |
CN101101547B (en) * | 2006-07-04 | 2012-07-18 | 霍尼韦尔(北京)技术研发实验有限公司 | Dynamic computer system and structure |
US8176467B2 (en) * | 2006-07-25 | 2012-05-08 | Harris Corporation | Computer program generation system and method thereof |
US7966599B1 (en) * | 2006-08-29 | 2011-06-21 | Adobe Systems Incorporated | Runtime library including a virtual file system |
US8200807B2 (en) * | 2006-08-31 | 2012-06-12 | The Mathworks, Inc. | Non-blocking local events in a state-diagramming environment |
US7917890B2 (en) * | 2006-08-31 | 2011-03-29 | Jon Barcellona | Enterprise-scale application development framework utilizing code generation |
US8589869B2 (en) * | 2006-09-07 | 2013-11-19 | Wolfram Alpha Llc | Methods and systems for determining a formula |
US8381180B2 (en) * | 2006-09-08 | 2013-02-19 | Sap Ag | Visually exposing data services to analysts |
US7584163B2 (en) * | 2006-09-14 | 2009-09-01 | Sap Ag | Method and system for expression evaluation |
WO2008034170A1 (en) * | 2006-09-20 | 2008-03-27 | National Ict Australia Limited | Generating a transition system for use with model checking |
US7904953B2 (en) * | 2006-09-22 | 2011-03-08 | Bea Systems, Inc. | Pagelets |
US8127278B2 (en) | 2006-09-28 | 2012-02-28 | Sap Ag | System and method for extending legacy applications with undo/redo functionality |
US7647522B2 (en) * | 2006-09-28 | 2010-01-12 | Microsoft Corporation | Operating system with corrective action service and isolation |
US8156480B2 (en) | 2006-09-29 | 2012-04-10 | Intel Corporation | Methods and apparatus to form a resilient objective instruction construct |
US8146051B2 (en) * | 2006-10-02 | 2012-03-27 | International Business Machines Corporation | Method and computer program product for providing a representation of software modeled by a model |
US8463852B2 (en) | 2006-10-06 | 2013-06-11 | Oracle International Corporation | Groupware portlets for integrating a portal with groupware systems |
US8739137B2 (en) * | 2006-10-19 | 2014-05-27 | Purdue Research Foundation | Automatic derivative method for a computer programming language |
US20080095196A1 (en) * | 2006-10-20 | 2008-04-24 | Rockwell Automation Technologies, Inc. | Unit to unit transfer synchronization |
US8601435B2 (en) * | 2006-10-20 | 2013-12-03 | Rockwell Automation Technologies, Inc. | Module class subsets for industrial control |
US8392008B2 (en) * | 2006-10-20 | 2013-03-05 | Rockwell Automation Technologies, Inc. | Module arbitration and ownership enhancements |
US7844349B2 (en) * | 2006-10-20 | 2010-11-30 | Rockwell Automation Technologies, Inc. | Standard MES interface for discrete manufacturing |
US7894917B2 (en) * | 2006-10-20 | 2011-02-22 | Rockwell Automation Technologies, Inc. | Automatic fault tuning |
JP4589294B2 (en) | 2006-11-21 | 2010-12-01 | 富士通株式会社 | Design / verification support program and recording medium recording the program |
EP1926019B1 (en) * | 2006-11-24 | 2012-05-16 | Tangro Software Components GmbH | Data exchange method and control method between software components as well as reusable software components. |
GB0624168D0 (en) * | 2006-12-04 | 2007-01-10 | Axiom Systems Ltd | Service assembly and delivery |
US8930890B2 (en) * | 2006-12-05 | 2015-01-06 | International Business Machines Corporation | Software model skinning |
US8756561B2 (en) * | 2006-12-05 | 2014-06-17 | International Business Machines Corporation | Software model normalization and mediation |
US7926026B2 (en) * | 2006-12-20 | 2011-04-12 | Sap Ag | Graphical analysis to detect process object anomalies |
US8689174B2 (en) * | 2006-12-28 | 2014-04-01 | Sap Ag | Extensibility of pattern components |
US8219650B2 (en) * | 2006-12-28 | 2012-07-10 | Sap Ag | Communicating with a status management component in a computer system |
US8843883B2 (en) * | 2007-01-03 | 2014-09-23 | International Business Machines Corporation | System and method for model-driven dashboard for business performance management |
US8161454B2 (en) * | 2007-01-22 | 2012-04-17 | Ford Motor Company | Software architecture for developing in-vehicle software applications |
US8812957B2 (en) * | 2007-01-31 | 2014-08-19 | Adobe Systems Incorporated | Relevance slider in a site analysis report |
US8997091B1 (en) * | 2007-01-31 | 2015-03-31 | Emc Corporation | Techniques for compliance testing |
US8099491B2 (en) * | 2007-01-31 | 2012-01-17 | Adobe Systems Incorporated | Intelligent node positioning in a site analysis report |
WO2008097801A2 (en) * | 2007-02-05 | 2008-08-14 | Skyway Software, Inc. | Method and system for creating, deploying, and utilizing a service |
US8336025B1 (en) | 2007-02-08 | 2012-12-18 | The Mathworks, Inc. | Pattern modeling methods and systems |
US8776015B1 (en) * | 2007-02-08 | 2014-07-08 | The Mathworks, Inc. | Pattern modeling methods and systems |
US8904340B2 (en) * | 2007-02-13 | 2014-12-02 | International Business Machines Corporation | Use of temporary optimized settings to reduce cycle time of automatically created spreadsheets |
KR100871563B1 (en) * | 2007-02-14 | 2008-12-02 | 삼성전자주식회사 | Apparatus and method for developing software based on component |
US8768689B2 (en) * | 2007-02-14 | 2014-07-01 | Nuance Communications, Inc. | Method and system for translation management of source language text phrases |
EP1965300A1 (en) * | 2007-03-02 | 2008-09-03 | Siemens Aktiengesellschaft | A method for validating a graphical workflow translation |
US20080235658A1 (en) * | 2007-03-21 | 2008-09-25 | Asaf Adi | Code generation for real-time event processing |
US20080256390A1 (en) * | 2007-04-13 | 2008-10-16 | Chaar Jarir K | Project Induction in a Software Factory |
US8327318B2 (en) * | 2007-04-13 | 2012-12-04 | International Business Machines Corporation | Software factory health monitoring |
US8566777B2 (en) * | 2007-04-13 | 2013-10-22 | International Business Machines Corporation | Work packet forecasting in a software factory |
US8359566B2 (en) * | 2007-04-13 | 2013-01-22 | International Business Machines Corporation | Software factory |
US8296719B2 (en) * | 2007-04-13 | 2012-10-23 | International Business Machines Corporation | Software factory readiness review |
US8141040B2 (en) * | 2007-04-13 | 2012-03-20 | International Business Machines Corporation | Assembling work packets within a software factory |
US8464205B2 (en) * | 2007-04-13 | 2013-06-11 | International Business Machines Corporation | Life cycle of a work packet in a software factory |
US8214796B2 (en) * | 2007-04-20 | 2012-07-03 | National Instruments Corporation | Event firing node for asynchronously passing events from a graphical data flow program to a statechart |
US8640100B2 (en) * | 2007-04-20 | 2014-01-28 | National Instruments Corporation | Debugging a statechart using a graphical program |
US8566793B2 (en) * | 2007-04-27 | 2013-10-22 | International Business Machines Corporation | Detecting and displaying errors in database statements within integrated development environment tool |
US8392880B2 (en) * | 2007-04-27 | 2013-03-05 | International Business Machines Corporation | Rapid application development for database-aware applications |
US9047337B2 (en) * | 2007-04-27 | 2015-06-02 | International Business Machines Corporation | Database connectivity and database model integration within integrated development environment tool |
US9489418B2 (en) | 2007-04-27 | 2016-11-08 | International Business Machines Corporation | Processing database queries embedded in application source code from within integrated development environment tool |
US20080276221A1 (en) * | 2007-05-02 | 2008-11-06 | Sap Ag. | Method and apparatus for relations planning and validation |
CN101681263B (en) * | 2007-05-16 | 2013-12-04 | 国际商业机器公司 | A consistent method system for developing software asset based solutions |
US8060868B2 (en) * | 2007-06-21 | 2011-11-15 | Microsoft Corporation | Fully capturing outer variables as data objects |
US8090735B2 (en) * | 2007-06-22 | 2012-01-03 | International Business Machines Corporation | Statement generation using statement patterns |
US8375351B2 (en) * | 2007-06-23 | 2013-02-12 | International Business Machines Corporation | Extensible rapid application development for disparate data sources |
US10783463B2 (en) * | 2007-06-27 | 2020-09-22 | International Business Machines Corporation | System, method and program for tracking labor costs |
US8001519B2 (en) * | 2007-06-27 | 2011-08-16 | International Business Machines Corporation | Model driven development including aspect integration tool |
US7702695B2 (en) * | 2007-06-27 | 2010-04-20 | Microsoft Corporation | Object relational map verification system |
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 |
US20090024979A1 (en) * | 2007-07-20 | 2009-01-22 | International Business Machines Corporation | Method and system for configuring a user interface |
US8141030B2 (en) * | 2007-08-07 | 2012-03-20 | International Business Machines Corporation | Dynamic routing and load balancing packet distribution with a software factory |
US8250534B2 (en) * | 2007-08-09 | 2012-08-21 | Infonovus Technologies, Llc | Method and system for constructing a software application from a complete and consistent specification in a software development process |
US8473910B2 (en) * | 2007-08-09 | 2013-06-25 | Infonovus Technologies, Llc | Method and system for defining a software application as a complete and consistent specification in a software development process |
US8332807B2 (en) * | 2007-08-10 | 2012-12-11 | International Business Machines Corporation | Waste determinants identification and elimination process model within a software factory operating environment |
US8689194B1 (en) | 2007-08-20 | 2014-04-01 | The Mathworks, Inc. | Optimization identification |
US9189757B2 (en) * | 2007-08-23 | 2015-11-17 | International Business Machines Corporation | Monitoring and maintaining balance of factory quality attributes within a software factory environment |
US8539437B2 (en) * | 2007-08-30 | 2013-09-17 | International Business Machines Corporation | Security process model for tasks within a software factory |
EP3023876A1 (en) * | 2007-08-31 | 2016-05-25 | Phase Change Software LLC | Quality assurance tools for use with source code and a semantic model |
US8429618B2 (en) * | 2007-09-19 | 2013-04-23 | Siemens Industry, Inc. | Parametric regular object types with comprehensions for automated generation of software test fixtures |
WO2009042129A2 (en) * | 2007-09-24 | 2009-04-02 | Simio Llc | A system and method for creating intelligent simulation objects using graphical process descriptions |
US8091094B2 (en) | 2007-10-10 | 2012-01-03 | Sap Ag | Methods and systems for ambistateful backend control |
US8381174B2 (en) * | 2007-10-31 | 2013-02-19 | National Instruments Corporation | Global variable structure in a graphical program |
US8316346B2 (en) | 2007-11-06 | 2012-11-20 | International Business Machines Corporation | Method and system for selecting a software architecture for implementing service integration |
JP5226283B2 (en) * | 2007-11-15 | 2013-07-03 | キヤノン株式会社 | Information processing apparatus, information processing system, method, and program |
US8671121B2 (en) | 2007-11-26 | 2014-03-11 | International Business Machines Corporation | Model augmentation in a model-driven application development environment |
US8266519B2 (en) * | 2007-11-27 | 2012-09-11 | Accenture Global Services Limited | Document analysis, commenting, and reporting system |
US8412516B2 (en) * | 2007-11-27 | 2013-04-02 | Accenture Global Services Limited | Document analysis, commenting, and reporting system |
US8271870B2 (en) * | 2007-11-27 | 2012-09-18 | Accenture Global Services Limited | Document analysis, commenting, and reporting system |
EP2071451A1 (en) * | 2007-12-07 | 2009-06-17 | Alcatel Lucent | Device and method for building compilable and executable applications from specifications expressed by classes |
US8458648B2 (en) * | 2007-12-10 | 2013-06-04 | International Business Machines Corporation | Graphical modelization of user interfaces for data intensive applications |
US8447657B2 (en) | 2007-12-31 | 2013-05-21 | Sap Ag | Architectural design for service procurement application software |
US8782618B1 (en) * | 2008-01-08 | 2014-07-15 | The Mathworks, Inc. | Instrument based processing |
US8468117B1 (en) * | 2008-01-22 | 2013-06-18 | Salesforce.Com, Inc. | System, method and computer program product for creating a visual component for tenants of an on-demand database service |
US8458667B2 (en) * | 2008-01-30 | 2013-06-04 | National Instruments Corporation | Debugging a statechart for a real time target |
US8370795B1 (en) * | 2008-01-31 | 2013-02-05 | Intuit Inc. | Method and system for explaining a value of a field in a form |
US8196112B1 (en) | 2008-02-15 | 2012-06-05 | Amazon Technologies, Inc. | Systems and methods for testing widgets in computer environments |
US20090210853A1 (en) * | 2008-02-19 | 2009-08-20 | Anand Kumar | Systems and apparatus for software development |
US8271951B2 (en) * | 2008-03-04 | 2012-09-18 | International Business Machines Corporation | System and methods for collecting software development feedback |
KR100994070B1 (en) * | 2008-03-19 | 2010-11-11 | (주)케투씨소프트 | A Reserved Component Container Based Software Development Method and Apparatus |
US20110010692A1 (en) * | 2008-03-21 | 2011-01-13 | The Bank Of Tokyo-Mitsubishi Ufj, Ltd. | Application development support device, program and storage medium |
US8504980B1 (en) | 2008-04-14 | 2013-08-06 | Sap Ag | Constraining data changes during transaction processing by a computer system |
US20100058198A1 (en) * | 2008-04-16 | 2010-03-04 | Modria, Inc. | Collaborative realtime planning using a model driven architecture and iterative planning tools |
US20090271765A1 (en) * | 2008-04-29 | 2009-10-29 | Microsoft Corporation | Consumer and producer specific semantics of shared object protocols |
US20090276757A1 (en) * | 2008-04-30 | 2009-11-05 | Fraunhofer Usa, Inc. | Systems and methods for inference and management of software code architectures |
US20090282384A1 (en) * | 2008-05-12 | 2009-11-12 | Raytheon Company | Framework-Based Model-Driven Software Development |
US8850409B2 (en) * | 2008-05-21 | 2014-09-30 | Optumsoft, Inc. | Notification-based constraint set translation to imperative execution |
US8595044B2 (en) * | 2008-05-29 | 2013-11-26 | International Business Machines Corporation | Determining competence levels of teams working within a software |
US8667469B2 (en) * | 2008-05-29 | 2014-03-04 | International Business Machines Corporation | Staged automated validation of work packets inputs and deliverables in a software factory |
US8010512B2 (en) * | 2008-06-16 | 2011-08-30 | International Business Machines Corporation | System and method for model-driven object store |
US8732838B2 (en) * | 2008-06-26 | 2014-05-20 | Microsoft Corporation | Evaluating the effectiveness of a threat model |
US8677310B2 (en) * | 2008-06-30 | 2014-03-18 | Rockwell Automation Technologies, Inc. | Industry template abstracting and creation for use in industrial automation and information solutions |
US8255869B2 (en) * | 2008-06-30 | 2012-08-28 | Rockwell Automation Technologies, Inc. | Industry template customization and transclusion for use in industrial automation and information solutions |
US8245191B2 (en) * | 2008-07-03 | 2012-08-14 | International Business Machines Corporation | Policy application rules for automated configuration of software components |
US9639331B2 (en) | 2008-07-09 | 2017-05-02 | International Business Machines Corporation | Service interface creation and modification for object-oriented services |
JP4894826B2 (en) | 2008-07-14 | 2012-03-14 | ソニー株式会社 | COMMUNICATION DEVICE, COMMUNICATION SYSTEM, NOTIFICATION METHOD, AND PROGRAM |
US8527329B2 (en) * | 2008-07-15 | 2013-09-03 | International Business Machines Corporation | Configuring design centers, assembly lines and job shops of a global delivery network into “on demand” factories |
US8452629B2 (en) * | 2008-07-15 | 2013-05-28 | International Business Machines Corporation | Work packet enabled active project schedule maintenance |
US8140367B2 (en) | 2008-07-22 | 2012-03-20 | International Business Machines Corporation | Open marketplace for distributed service arbitrage with integrated risk management |
US20100023920A1 (en) * | 2008-07-22 | 2010-01-28 | International Business Machines Corporation | Intelligent job artifact set analyzer, optimizer and re-constructor |
US8418126B2 (en) * | 2008-07-23 | 2013-04-09 | International Business Machines Corporation | Software factory semantic reconciliation of data models for work packets |
US8375370B2 (en) * | 2008-07-23 | 2013-02-12 | International Business Machines Corporation | Application/service event root cause traceability causal and impact analyzer |
US8271949B2 (en) * | 2008-07-31 | 2012-09-18 | International Business Machines Corporation | Self-healing factory processes in a software factory |
US8448129B2 (en) * | 2008-07-31 | 2013-05-21 | International Business Machines Corporation | Work packet delegation in a software factory |
US8336026B2 (en) * | 2008-07-31 | 2012-12-18 | International Business Machines Corporation | Supporting a work packet request with a specifically tailored IDE |
US20100031175A1 (en) * | 2008-08-04 | 2010-02-04 | Michael Lee Kijewski | Computerized method for relating variables in user-defined equations to dimensions on digital drawings |
EP2329376A1 (en) * | 2008-08-15 | 2011-06-08 | Verum Holding B.V. | A method and system for testing complex machine control software |
AU2009287407A1 (en) * | 2008-08-26 | 2010-03-04 | Cinergix Pty Ltd | Modelling of systems |
US8401928B2 (en) * | 2008-09-18 | 2013-03-19 | Sap Ag | Providing supplier relationship management software application as enterprise services |
US8584085B2 (en) * | 2008-09-24 | 2013-11-12 | Accenture Global Services Limited | Identification of concepts in software |
US9335761B2 (en) * | 2008-09-30 | 2016-05-10 | Rockwell Automation Technologies, Inc. | Procedure classification for industrial automation |
US20100088685A1 (en) * | 2008-10-06 | 2010-04-08 | Microsoft Corporation | System and method for mapping a domain modeling language to a relational store |
US8356288B2 (en) * | 2008-11-10 | 2013-01-15 | Sap Ag | Method and apparatus for monitoring runtime of persistence applications |
JP2010128583A (en) * | 2008-11-25 | 2010-06-10 | Toshiba Corp | Test-facilitating design apparatus, its method and program |
US8401908B2 (en) | 2008-12-03 | 2013-03-19 | Sap Ag | Architectural design for make-to-specification application software |
JP5327230B2 (en) * | 2008-12-05 | 2013-10-30 | 富士通株式会社 | Operation management support program, recording medium recording the program, operation management support device, and operation management support method |
US8671035B2 (en) | 2008-12-11 | 2014-03-11 | Sap Ag | Providing payroll software application as enterprise services |
US8949788B2 (en) * | 2008-12-17 | 2015-02-03 | Red Hat, Inc. | Building and packaging software |
US8495596B1 (en) * | 2009-02-09 | 2013-07-23 | Amdocs Software Systems Limited | System, method, and computer program for interfacing an automatic operational support system with a legacy operational support system |
US20100235275A1 (en) * | 2009-03-06 | 2010-09-16 | Carl Ansley | Card Processing |
US8849873B2 (en) * | 2009-03-18 | 2014-09-30 | Bentley Systems, Incorporated | Specifications automation system and method |
TW201106251A (en) | 2009-04-24 | 2011-02-16 | Ibm | Editing apparatus, editing method and program |
US8601015B1 (en) | 2009-05-15 | 2013-12-03 | Wolfram Alpha Llc | Dynamic example generation for queries |
US8788524B1 (en) | 2009-05-15 | 2014-07-22 | Wolfram Alpha Llc | Method and system for responding to queries in an imprecise syntax |
JP5304475B2 (en) * | 2009-06-23 | 2013-10-02 | 富士通株式会社 | Information processing apparatus and information processing method |
US8595697B2 (en) * | 2009-07-01 | 2013-11-26 | International Business Machines Corporation | Serializing a templated markup language representation of test artifacts |
FR2948788B1 (en) * | 2009-07-30 | 2011-09-16 | Xaga Network | APPLICATION MANAGEMENT SYSTEM |
US8589858B1 (en) * | 2009-09-14 | 2013-11-19 | Lockheed Martin Corporation | Requirement manager for UML and SysML application |
US8706771B2 (en) * | 2009-09-30 | 2014-04-22 | Smartshift Gmbh | Systems and methods for analyzing and transforming an application from a source installation to a target installation |
US8301168B2 (en) * | 2009-10-16 | 2012-10-30 | At&T Mobility Ii Llc | Devices and methods for selectively filtering message content |
US10185594B2 (en) * | 2009-10-29 | 2019-01-22 | International Business Machines Corporation | System and method for resource identification |
US8436867B1 (en) * | 2009-11-06 | 2013-05-07 | Pixar | System and method for generating computer graphic images by identifying variant and invariant shader arguments |
US8677313B2 (en) * | 2009-11-30 | 2014-03-18 | Accenture Global Services Limited | Functional design creation tool |
US8707250B2 (en) * | 2009-12-22 | 2014-04-22 | Board Of Regents, The University Of Texas System | Automation support for domain modeling |
US8549353B2 (en) * | 2009-12-29 | 2013-10-01 | Microgen Aptitutde Limited | Batch processing error handling modes |
US8997053B2 (en) * | 2010-01-14 | 2015-03-31 | Worksoft, Inc. | System and method for automated testing of software applications with dynamic user interfaces spanning multiple technologies |
US20110191748A1 (en) * | 2010-01-29 | 2011-08-04 | International Business Machines Corporation | Systems and methods for design time service verification and validation |
EP2362333A1 (en) | 2010-02-19 | 2011-08-31 | Accenture Global Services Limited | System for requirement identification and analysis based on capability model structure |
US20110213637A1 (en) * | 2010-02-26 | 2011-09-01 | Gm Global Technology Operations, Inc | Requirements engineering tool called requirement editor |
US9116708B2 (en) * | 2010-03-05 | 2015-08-25 | Nec Corporation | Program creation support apparatus, program, and information system |
US8949773B2 (en) * | 2010-03-25 | 2015-02-03 | International Business Machines Corporation | Deriving process models from natural language use case models |
US9146913B2 (en) | 2010-03-29 | 2015-09-29 | Bentley Systems, Incorporated | Specifications automation system and method |
US8701080B2 (en) | 2010-04-05 | 2014-04-15 | Accenture Global Services Limited | Template components having constraints representative of best practices in integration software development |
US8495580B2 (en) | 2010-04-07 | 2013-07-23 | International Business Machines Corporation | Facilitating use of model transformations |
US8739118B2 (en) | 2010-04-08 | 2014-05-27 | Microsoft Corporation | Pragmatic mapping specification, compilation and validation |
US8484015B1 (en) | 2010-05-14 | 2013-07-09 | Wolfram Alpha Llc | Entity pages |
US20110302551A1 (en) * | 2010-06-02 | 2011-12-08 | Hummel Jr David Martin | System and method for analytic process design |
US8473895B2 (en) * | 2010-06-08 | 2013-06-25 | Microsoft Corporation | Providing diverse solutions using design space exploration |
US20110314449A1 (en) * | 2010-06-18 | 2011-12-22 | Infosys Technologies Limited | Method and system for estimating effort for maintenance of software |
US8607191B2 (en) * | 2010-06-30 | 2013-12-10 | International Business Machines Corporation | Automated discovery of programmatic resources |
US8566731B2 (en) | 2010-07-06 | 2013-10-22 | Accenture Global Services Limited | Requirement statement manipulation system |
US8572574B2 (en) * | 2010-07-16 | 2013-10-29 | Fujitsu Limited | Solving hybrid constraints to validate specification requirements of a software module |
US8812298B1 (en) | 2010-07-28 | 2014-08-19 | Wolfram Alpha Llc | Macro replacement of natural language input |
US8510650B2 (en) * | 2010-08-11 | 2013-08-13 | Stephen J. Garland | Multiple synchronized views for creating, analyzing, editing, and using mathematical formulas |
US8407073B2 (en) | 2010-08-25 | 2013-03-26 | International Business Machines Corporation | Scheduling resources from a multi-skill multi-level human resource pool |
US9087236B2 (en) * | 2010-09-13 | 2015-07-21 | International Business Machines Corporation | Automated recognition of process modeling semantics in flow diagrams |
US8776014B2 (en) | 2010-09-23 | 2014-07-08 | Microsoft Corporation | Software build analysis |
US9177017B2 (en) * | 2010-09-27 | 2015-11-03 | Microsoft Technology Licensing, Llc | Query constraint encoding with type-based state machine |
WO2012048162A2 (en) | 2010-10-08 | 2012-04-12 | Irise | System and method for extending a visualization platform |
WO2012069077A1 (en) * | 2010-11-23 | 2012-05-31 | Nokia Siemens Networks Oy | Network element configuration management |
CN103299292B (en) * | 2010-12-02 | 2016-01-20 | Sk电信有限公司 | For the treatment of method and the equipment thereof of natural language and mathematical formulae |
US9069448B2 (en) * | 2010-12-03 | 2015-06-30 | Salesforce.Com, Inc. | Filtering objects in a multi-tenant environment |
EP2466455A1 (en) * | 2010-12-15 | 2012-06-20 | Schneider Electric Buildings AB | Definition of objects in object-oriented programming environments |
US20120180033A1 (en) * | 2011-01-12 | 2012-07-12 | David Amos Brown | System and Methodology for Autonomous, Value-Centric, Architectural, Software Programming |
US9015011B2 (en) * | 2011-01-25 | 2015-04-21 | Accenture Global Services Limited | Assistant tool |
US9280442B1 (en) | 2011-01-27 | 2016-03-08 | Trimble Navigation Limited | System and method for generating coverage reports for software unit tests |
US9043759B1 (en) | 2011-01-27 | 2015-05-26 | Trimble Navigation Limited | System and method for generating software unit tests simultaneously with API documentation |
US9400778B2 (en) | 2011-02-01 | 2016-07-26 | Accenture Global Services Limited | System for identifying textual relationships |
US8856734B2 (en) | 2011-03-11 | 2014-10-07 | Oracle International Corporation | Type-safe dependency injection of services into enterprise components |
US8706881B2 (en) * | 2011-03-22 | 2014-04-22 | Oracle International Corporation | Automatic registration of enterprise resources in a dynamic module system services registry |
US20120246609A1 (en) | 2011-03-24 | 2012-09-27 | International Business Machines Corporation | Automatic generation of user stories for software products via a product content space |
US9319359B1 (en) | 2011-03-31 | 2016-04-19 | Twitter, Inc. | Promoting content in a real-time messaging platform |
US10543715B2 (en) | 2016-09-08 | 2020-01-28 | Stempf Automotive Industries, Inc. | Wheel centering sleeve |
US9117227B1 (en) | 2011-03-31 | 2015-08-25 | Twitter, Inc. | Temporal features in a messaging platform |
US8682895B1 (en) * | 2011-03-31 | 2014-03-25 | Twitter, Inc. | Content resonance |
WO2012141996A1 (en) * | 2011-04-10 | 2012-10-18 | Requirementslive Llc | Portable business language and automated software application development system |
US8935654B2 (en) | 2011-04-21 | 2015-01-13 | Accenture Global Services Limited | Analysis system for test artifact generation |
US9817677B2 (en) * | 2011-04-22 | 2017-11-14 | Microsoft Technologies Licensing, LLC | Rule based data driven validation |
JP2012238235A (en) * | 2011-05-12 | 2012-12-06 | Canon Inc | Program verification device and program |
US9123002B2 (en) * | 2011-05-27 | 2015-09-01 | Abbott Informatics Corporation | Graphically based method for developing rules for managing a laboratory workflow |
US8660878B2 (en) | 2011-06-15 | 2014-02-25 | International Business Machines Corporation | Model-driven assignment of work to a software factory |
US9063672B2 (en) * | 2011-07-11 | 2015-06-23 | Honeywell International Inc. | Systems and methods for verifying model equivalence |
US9268665B2 (en) | 2011-07-26 | 2016-02-23 | Trimble Navigation Limited | System and method for identifying fault prone computer code files |
US9069814B2 (en) | 2011-07-27 | 2015-06-30 | Wolfram Alpha Llc | Method and system for using natural language to generate widgets |
US8676864B2 (en) * | 2011-08-19 | 2014-03-18 | Salesforce.Com, Inc. | Methods and systems for providing schema layout in an on-demand services environment |
US9507871B2 (en) * | 2011-08-29 | 2016-11-29 | The Boeing Company | Methods and systems for a state-based web framework architecture |
US9063673B2 (en) * | 2011-08-30 | 2015-06-23 | Uniquesoft, Llc | System and method for implementing application code from application requirements |
US9734252B2 (en) | 2011-09-08 | 2017-08-15 | Wolfram Alpha Llc | Method and system for analyzing data using a query answering system |
US8898628B2 (en) | 2011-09-23 | 2014-11-25 | Ahmad RAZA | Method and an apparatus for developing software |
US8943470B2 (en) * | 2011-09-23 | 2015-01-27 | The Mathworks, Inc. | Requirements framework |
US9940327B2 (en) * | 2011-10-12 | 2018-04-10 | International Business Machines Corporation | Method for generating workflow from business specification |
US9244819B2 (en) * | 2011-10-31 | 2016-01-26 | International Business Machines Corporation | Attribute value properties for test selection with cartesian product models |
US9851950B2 (en) | 2011-11-15 | 2017-12-26 | Wolfram Alpha Llc | Programming in a precise syntax using natural language |
US10802687B2 (en) | 2011-12-04 | 2020-10-13 | Salesforce.Com, Inc. | Displaying differences between different data sets of a process |
US10796232B2 (en) | 2011-12-04 | 2020-10-06 | Salesforce.Com, Inc. | Explaining differences between predicted outcomes and actual outcomes of a process |
US8577840B2 (en) * | 2012-01-03 | 2013-11-05 | International Business Machines Corporation | Replication of data sets |
GB2490190A (en) * | 2012-01-11 | 2012-10-24 | Accenture Global Services Ltd | Testing a requirement statement using a grammatical parser and applying a test artefact rule set. |
CN102609402B (en) * | 2012-01-12 | 2014-02-12 | 北京航空航天大学 | Device and method for generation and management of ontology model based on real-time strategy |
WO2013111316A1 (en) * | 2012-01-27 | 2013-08-01 | 富士通株式会社 | Information processing method, device and program |
US9152385B2 (en) * | 2012-02-22 | 2015-10-06 | GM Global Technology Operations LLC | Systems and methods for generating high-quality formal executable software feature requirements |
US9021420B2 (en) * | 2012-03-02 | 2015-04-28 | Xerox Corporation | Deployment of business processes in service-oriented architecture environments |
EP2639693A1 (en) * | 2012-03-12 | 2013-09-18 | Barium AB | Business management system |
US20130246995A1 (en) * | 2012-03-13 | 2013-09-19 | Outsystems - Software Em Rede S.A. | Systems, methods, and apparatus for model-based security control |
US9389872B2 (en) * | 2012-03-16 | 2016-07-12 | Vmware, Inc. | Software wizard implementation framework |
US9075616B2 (en) * | 2012-03-19 | 2015-07-07 | Enterpriseweb Llc | Declarative software application meta-model and system for self-modification |
US9977655B2 (en) * | 2012-03-20 | 2018-05-22 | Massively Parallel Technologies, Inc. | System and method for automatic extraction of software design from requirements |
US9424168B2 (en) * | 2012-03-20 | 2016-08-23 | Massively Parallel Technologies, Inc. | System and method for automatic generation of software test |
US8996472B2 (en) | 2012-04-16 | 2015-03-31 | Sap Se | Verification of status schemas based on business goal definitions |
US9400983B1 (en) | 2012-05-10 | 2016-07-26 | Jpmorgan Chase Bank, N.A. | Method and system for implementing behavior isolating prediction model |
US8850407B2 (en) * | 2012-05-23 | 2014-09-30 | Hewlett-Packard Development Company, L.P. | Test script generation |
US9400639B2 (en) | 2012-06-22 | 2016-07-26 | Microsoft Technology Licensing, Llc | Generating programs using context-free compositions and probability of determined transformation rules |
US9460200B2 (en) | 2012-07-02 | 2016-10-04 | International Business Machines Corporation | Activity recommendation based on a context-based electronic files search |
US8903813B2 (en) | 2012-07-02 | 2014-12-02 | International Business Machines Corporation | Context-based electronic document search using a synthetic event |
US8898165B2 (en) | 2012-07-02 | 2014-11-25 | International Business Machines Corporation | Identification of null sets in a context-based electronic document search |
US9098586B1 (en) | 2012-07-05 | 2015-08-04 | EarthNetTV Inc. | Private user interest recognition and targeted recommendation system |
US20140012740A1 (en) * | 2012-07-06 | 2014-01-09 | Great Bridge Corporation | Collecting and analyzing transaction datacollecting and analyzing transaction and demographic data to fulfill queries and target surveys |
US9027001B2 (en) | 2012-07-10 | 2015-05-05 | Honeywell International Inc. | Systems and methods for verifying expression folding |
US8966441B2 (en) * | 2012-07-12 | 2015-02-24 | Oracle International Corporation | Dynamic scripts to extend static applications |
US9009736B2 (en) * | 2012-07-26 | 2015-04-14 | Sap Se | Function execution framework wrapper layer |
US8996473B2 (en) | 2012-08-06 | 2015-03-31 | Sap Se | Checking compatibility of extended and core SAM schemas based on complex goals |
US9262499B2 (en) | 2012-08-08 | 2016-02-16 | International Business Machines Corporation | Context-based graphical database |
US20140052757A1 (en) * | 2012-08-17 | 2014-02-20 | International Business Machines Corporation | Techniques providing a software fitting assessment |
US8959119B2 (en) | 2012-08-27 | 2015-02-17 | International Business Machines Corporation | Context-based graph-relational intersect derived database |
US9405424B2 (en) | 2012-08-29 | 2016-08-02 | Wolfram Alpha, Llc | Method and system for distributing and displaying graphical items |
US20150019537A1 (en) | 2012-09-07 | 2015-01-15 | Splunk Inc. | Generating Reports from Unstructured Data |
US8788525B2 (en) * | 2012-09-07 | 2014-07-22 | Splunk Inc. | Data model for machine data for semantic search |
US9582585B2 (en) | 2012-09-07 | 2017-02-28 | Splunk Inc. | Discovering fields to filter data returned in response to a search |
US8620958B1 (en) | 2012-09-11 | 2013-12-31 | International Business Machines Corporation | Dimensionally constrained synthetic context objects database |
US9619580B2 (en) | 2012-09-11 | 2017-04-11 | International Business Machines Corporation | Generation of synthetic context objects |
US9251237B2 (en) | 2012-09-11 | 2016-02-02 | International Business Machines Corporation | User-specific synthetic context object matching |
US9111102B2 (en) * | 2012-09-17 | 2015-08-18 | Microsoft Technology Licensing, Llc | Creation of security roles through user walkthrough of business process workflow |
US9223846B2 (en) | 2012-09-18 | 2015-12-29 | International Business Machines Corporation | Context-based navigation through a database |
US9280322B2 (en) * | 2012-09-27 | 2016-03-08 | Intel Corporation | Generating source code |
US8826240B1 (en) * | 2012-09-29 | 2014-09-02 | Appurify, Inc. | Application validation through object level hierarchy analysis |
US9741138B2 (en) | 2012-10-10 | 2017-08-22 | International Business Machines Corporation | Node cluster relationships in a graph database |
US8931109B2 (en) | 2012-11-19 | 2015-01-06 | International Business Machines Corporation | Context-based security screening for accessing data |
US9612947B2 (en) | 2012-12-03 | 2017-04-04 | Ca, Inc. | Code-free testing framework |
US9058240B2 (en) * | 2012-12-03 | 2015-06-16 | International Business Machines Corporation | Multi-context remote development |
US9465591B2 (en) * | 2012-12-17 | 2016-10-11 | Unisys Corporation | Syntax language generator for compiler validation |
US9229932B2 (en) | 2013-01-02 | 2016-01-05 | International Business Machines Corporation | Conformed dimensional data gravity wells |
US8983981B2 (en) | 2013-01-02 | 2015-03-17 | International Business Machines Corporation | Conformed dimensional and context-based data gravity wells |
US8914413B2 (en) * | 2013-01-02 | 2014-12-16 | International Business Machines Corporation | Context-based data gravity wells |
US9043290B2 (en) * | 2013-01-14 | 2015-05-26 | International Business Machines Corporation | Rewriting relational expressions for different type systems |
US9218161B2 (en) | 2013-01-15 | 2015-12-22 | International Business Machines Corporation | Embedding a software content space for run-time implementation |
US9111040B2 (en) | 2013-01-15 | 2015-08-18 | International Business Machines Corporation | Integration of a software content space with test planning and test case generation |
US9063809B2 (en) | 2013-01-15 | 2015-06-23 | International Business Machines Corporation | Content space environment representation |
US9396342B2 (en) | 2013-01-15 | 2016-07-19 | International Business Machines Corporation | Role based authorization based on product content space |
US9081645B2 (en) | 2013-01-15 | 2015-07-14 | International Business Machines Corporation | Software product licensing based on a content space |
US9659053B2 (en) | 2013-01-15 | 2017-05-23 | International Business Machines Corporation | Graphical user interface streamlining implementing a content space |
US9141379B2 (en) | 2013-01-15 | 2015-09-22 | International Business Machines Corporation | Automated code coverage measurement and tracking per user story and requirement |
US9075544B2 (en) | 2013-01-15 | 2015-07-07 | International Business Machines Corporation | Integration and user story generation and requirements management |
US9069647B2 (en) | 2013-01-15 | 2015-06-30 | International Business Machines Corporation | Logging and profiling content space data and coverage metric self-reporting |
US9087155B2 (en) | 2013-01-15 | 2015-07-21 | International Business Machines Corporation | Automated data collection, computation and reporting of content space coverage metrics for software products |
US9069752B2 (en) | 2013-01-31 | 2015-06-30 | International Business Machines Corporation | Measuring and displaying facets in context-based conformed dimensional data gravity wells |
US8856946B2 (en) | 2013-01-31 | 2014-10-07 | International Business Machines Corporation | Security filter for context-based data gravity wells |
US10067855B2 (en) * | 2013-01-31 | 2018-09-04 | Entit Software Llc | Error developer association |
US9053102B2 (en) | 2013-01-31 | 2015-06-09 | International Business Machines Corporation | Generation of synthetic context frameworks for dimensionally constrained hierarchical synthetic context-based objects |
US9292506B2 (en) | 2013-02-28 | 2016-03-22 | International Business Machines Corporation | Dynamic generation of demonstrative aids for a meeting |
US9110722B2 (en) | 2013-02-28 | 2015-08-18 | International Business Machines Corporation | Data processing work allocation |
US9672228B2 (en) | 2013-03-11 | 2017-06-06 | Honeywell International Inc. | Methods and systems for creating a complex user interface adapting a generic database software application to individually manage subset domains in complex database |
US10078575B2 (en) * | 2013-03-13 | 2018-09-18 | Microsoft Technology Licensing, Llc | Diagnostics of state transitions |
US9280323B2 (en) * | 2013-03-13 | 2016-03-08 | Sap Se | Display of source code semantic layers |
US9229688B2 (en) | 2013-03-14 | 2016-01-05 | Massively Parallel Technologies, Inc. | Automated latency management and cross-communication exchange conversion |
US20140282369A1 (en) * | 2013-03-14 | 2014-09-18 | Adminovate, Inc. | Software application generator |
US10650408B1 (en) | 2013-03-15 | 2020-05-12 | Twitter, Inc. | Budget smoothing in a messaging platform |
US9134962B1 (en) | 2013-03-15 | 2015-09-15 | Sanctum Solutions, Inc. | Interactive content development |
US9361322B1 (en) | 2013-03-15 | 2016-06-07 | Twitter, Inc. | Unidirectional lookalike campaigns in a messaging platform |
US9661453B2 (en) * | 2013-03-16 | 2017-05-23 | Fairwayiq, Inc. | Intelligent golf course |
TWI622931B (en) | 2013-03-19 | 2018-05-01 | 動態微型系統公司 | Tool compiler |
US10152526B2 (en) | 2013-04-11 | 2018-12-11 | International Business Machines Corporation | Generation of synthetic context objects using bounded context objects |
US10700920B2 (en) | 2013-04-29 | 2020-06-30 | Moogsoft, Inc. | System and methods for decomposing events from managed infrastructures that includes a floating point unit |
US11010220B2 (en) | 2013-04-29 | 2021-05-18 | Moogsoft, Inc. | System and methods for decomposing events from managed infrastructures that includes a feedback signalizer functor |
US9529890B2 (en) | 2013-04-29 | 2016-12-27 | Moogsoft, Inc. | System for decomposing events from managed infrastructures using a topology proximity engine, graph topologies, and k-means clustering |
US10803133B2 (en) | 2013-04-29 | 2020-10-13 | Moogsoft Inc. | System for decomposing events from managed infrastructures that includes a reference tool signalizer |
US10417594B2 (en) | 2013-05-02 | 2019-09-17 | Sap Se | Validation of functional correctness of SAM schemas including action chains |
US10346388B2 (en) * | 2013-05-03 | 2019-07-09 | Sap Se | Performance and quality optimized architecture for cloud applications |
US9348794B2 (en) | 2013-05-17 | 2016-05-24 | International Business Machines Corporation | Population of context-based data gravity wells |
US9195608B2 (en) | 2013-05-17 | 2015-11-24 | International Business Machines Corporation | Stored data analysis |
US10296618B1 (en) | 2013-05-20 | 2019-05-21 | EMC IP Holding Company LLC | Storage system query mechanism and techniques |
US10467207B2 (en) * | 2013-05-24 | 2019-11-05 | Sap Se | Handling changes in automatic sort |
US9940104B2 (en) * | 2013-06-11 | 2018-04-10 | Microsoft Technology Licensing, Llc. | Automatic source code generation |
US9485306B2 (en) | 2013-06-21 | 2016-11-01 | Here Global B.V. | Methods, apparatuses, and computer program products for facilitating a data interchange protocol |
US9454348B2 (en) | 2013-06-21 | 2016-09-27 | Here Global B.V. | Methods, apparatuses, and computer program products for facilitating a data interchange protocol modeling language |
US9569469B2 (en) * | 2013-07-26 | 2017-02-14 | Honeywell International Inc. | Methods and systems for providing intuitive direction for populating complex model content into a database |
IN2013MU02497A (en) | 2013-07-29 | 2015-06-26 | Tata Consultancy Services Ltd | |
US9223773B2 (en) * | 2013-08-08 | 2015-12-29 | Palatir Technologies Inc. | Template system for custom document generation |
US9329849B2 (en) | 2013-08-26 | 2016-05-03 | Facebook, Inc. | Systems and methods for converting typed code |
US9639572B2 (en) | 2013-09-06 | 2017-05-02 | Sap Se | SQL enhancements simplifying database querying |
US9354948B2 (en) | 2013-09-06 | 2016-05-31 | Sap Se | Data models containing host language embedded constraints |
US9361407B2 (en) | 2013-09-06 | 2016-06-07 | Sap Se | SQL extended with transient fields for calculation expressions in enhanced data models |
US9442977B2 (en) | 2013-09-06 | 2016-09-13 | Sap Se | Database language extended to accommodate entity-relationship models |
US9176801B2 (en) * | 2013-09-06 | 2015-11-03 | Sap Se | Advanced data models containing declarative and programmatic constraints |
US9619552B2 (en) | 2013-09-06 | 2017-04-11 | Sap Se | Core data services extensibility for entity-relationship models |
US9430523B2 (en) | 2013-09-06 | 2016-08-30 | Sap Se | Entity-relationship model extensions using annotations |
US9146712B2 (en) * | 2013-09-18 | 2015-09-29 | Vmware, Inc. | Extensible code auto-fix framework based on XML query languages |
US8819617B1 (en) * | 2013-09-19 | 2014-08-26 | Fmr Llc | System and method for providing access to data in a plurality of software development systems |
US9092575B2 (en) | 2013-09-19 | 2015-07-28 | Fmr Llc | System and method for providing access to data in a plurality of software development systems |
US20150095849A1 (en) | 2013-09-30 | 2015-04-02 | Microsoft Corporation | Dialogs positioned with action visualization |
US10394533B2 (en) * | 2013-09-30 | 2019-08-27 | The Mathworks, Inc. | Reusable component in a modeling environment |
US10521753B2 (en) * | 2013-10-09 | 2019-12-31 | Sap Se | Usage description language |
IN2013MU03243A (en) * | 2013-10-15 | 2015-07-17 | Tata Consultancy Services Ltd | |
US9311124B2 (en) | 2013-11-07 | 2016-04-12 | Sap Se | Integrated deployment of centrally modified software systems |
US9823905B2 (en) * | 2013-11-11 | 2017-11-21 | International Business Machines Corporation | Event based code generation |
DE102013225058A1 (en) * | 2013-12-05 | 2015-06-11 | Fraunhofer-Gesellschaft zur Förderung der angewandten Forschung e.V. | DEVICE, SYSTEM AND METHOD FOR THE EFFICIENT AND DELIVERABLE SYNCHRONIZATION OF GRAPHIC DATA STRUCTURES |
US11087340B1 (en) * | 2013-12-17 | 2021-08-10 | EMC IP Holding Company LLC | Systems and methods for configuring converged infrastructure components |
IN2013CH06085A (en) * | 2013-12-26 | 2015-07-03 | Inforys Ltd | |
JP6249770B2 (en) * | 2013-12-27 | 2017-12-20 | キヤノン株式会社 | Character input device |
US9454620B2 (en) * | 2014-02-28 | 2016-09-27 | Here Global B.V. | Methods, apparatuses and computer program products for automated learning of data models |
EP2916183B1 (en) * | 2014-03-06 | 2016-11-09 | dSPACE digital signal processing and control engineering GmbH | Method for generating a control program for a control system |
US9268537B1 (en) * | 2014-04-29 | 2016-02-23 | The Mathworks, Inc. | Automatic generation of domain-aware phase ordering for effective optimization of code for a model |
FR3021769B1 (en) | 2014-05-27 | 2016-07-01 | Thales Sa | DEVICE AND METHOD FOR GENERATING AT LEAST ONE COMPUTER FILE FOR PRODUCING A GRAPHICAL INTERFACE OF ELECTRONIC EQUIPMENT, AND ASSOCIATED COMPUTER PROGRAM PRODUCT |
US9736032B2 (en) * | 2014-05-30 | 2017-08-15 | Microsoft Technology Licensing, Llc | Pattern-based validation, constraint and generation of hierarchical metadata |
US20150356090A1 (en) * | 2014-06-09 | 2015-12-10 | Northwestern University | System and Method for Dynamically Constructing Theatrical Experiences from Digital Content |
CN105320504B (en) * | 2014-06-25 | 2018-08-17 | 成都普中软件有限公司 | A kind of visual software modeling method constructing software view based on software member view |
US11100420B2 (en) | 2014-06-30 | 2021-08-24 | Amazon Technologies, Inc. | Input processing for machine learning |
US9886670B2 (en) * | 2014-06-30 | 2018-02-06 | Amazon Technologies, Inc. | Feature processing recipes for machine learning |
US10452992B2 (en) | 2014-06-30 | 2019-10-22 | Amazon Technologies, Inc. | Interactive interfaces for machine learning model evaluations |
US10540606B2 (en) | 2014-06-30 | 2020-01-21 | Amazon Technologies, Inc. | Consistent filtering of machine learning data |
US9672474B2 (en) | 2014-06-30 | 2017-06-06 | Amazon Technologies, Inc. | Concurrent binning of machine learning data |
US10169715B2 (en) | 2014-06-30 | 2019-01-01 | Amazon Technologies, Inc. | Feature processing tradeoff management |
US10963810B2 (en) | 2014-06-30 | 2021-03-30 | Amazon Technologies, Inc. | Efficient duplicate detection for machine learning data sets |
CA2953817C (en) * | 2014-06-30 | 2023-07-04 | Amazon Technologies, Inc. | Feature processing tradeoff management |
US10102480B2 (en) | 2014-06-30 | 2018-10-16 | Amazon Technologies, Inc. | Machine learning service |
US10339465B2 (en) | 2014-06-30 | 2019-07-02 | Amazon Technologies, Inc. | Optimized decision tree based models |
US10318882B2 (en) | 2014-09-11 | 2019-06-11 | Amazon Technologies, Inc. | Optimized training of linear machine learning models |
US9844723B2 (en) * | 2014-07-25 | 2017-12-19 | Zynga Inc. | In-browser emulation of multiple technologies to create consistent visualization experience |
GB2528697A (en) * | 2014-07-29 | 2016-02-03 | Ibm | Generating a database structure from a scanned drawing |
US11182691B1 (en) | 2014-08-14 | 2021-11-23 | Amazon Technologies, Inc. | Category-based sampling of machine learning data |
US10275458B2 (en) | 2014-08-14 | 2019-04-30 | International Business Machines Corporation | Systematic tuning of text analytic annotators with specialized information |
US9158786B1 (en) | 2014-10-01 | 2015-10-13 | Bertram Capital Management, Llc | Database selection system and method to automatically adjust a database schema based on an input data |
US20160098256A1 (en) * | 2014-10-03 | 2016-04-07 | General Motors Llc | Visual tool and architecting logical layers of software components |
US9851949B2 (en) * | 2014-10-07 | 2017-12-26 | Kevin D. Howard | System and method for automatic software application creation |
US10275154B2 (en) | 2014-11-05 | 2019-04-30 | Oracle International Corporation | Building memory layouts in software programs |
US9552192B2 (en) * | 2014-11-05 | 2017-01-24 | Oracle International Corporation | Context-based generation of memory layouts in software programs |
US10353793B2 (en) | 2014-11-05 | 2019-07-16 | Oracle International Corporation | Identifying improvements to memory usage of software programs |
US10108536B2 (en) | 2014-12-10 | 2018-10-23 | General Electric Company | Integrated automated test case generation for safety-critical software |
US9747079B2 (en) * | 2014-12-15 | 2017-08-29 | General Electric Company | Method and system of software specification modeling |
US9563450B1 (en) * | 2014-12-15 | 2017-02-07 | Emc Corporation | Expression based hierarchical mechanism for HTML form data validation |
US10425291B2 (en) | 2015-01-27 | 2019-09-24 | Moogsoft Inc. | System for decomposing events from managed infrastructures with prediction of a networks topology |
US11924018B2 (en) | 2015-01-27 | 2024-03-05 | Dell Products L.P. | System for decomposing events and unstructured data |
US10979304B2 (en) | 2015-01-27 | 2021-04-13 | Moogsoft Inc. | Agent technology system with monitoring policy |
US10873508B2 (en) | 2015-01-27 | 2020-12-22 | Moogsoft Inc. | Modularity and similarity graphics system with monitoring policy |
US11817993B2 (en) | 2015-01-27 | 2023-11-14 | Dell Products L.P. | System for decomposing events and unstructured data |
US10402390B1 (en) * | 2015-02-11 | 2019-09-03 | Workday, Inc. | Model validation system |
WO2016133533A1 (en) * | 2015-02-20 | 2016-08-25 | Hewlett Packard Enterprise Development Lp | Personalized profile-modified search for dialog concepts |
US9971838B2 (en) | 2015-02-20 | 2018-05-15 | International Business Machines Corporation | Mitigating subjectively disturbing content through the use of context-based data gravity wells |
US10275227B1 (en) * | 2015-02-20 | 2019-04-30 | The Mathworks, Inc. | Determining functional equivalence of configurations of a model |
US20160246582A1 (en) * | 2015-02-25 | 2016-08-25 | Red Hat, Inc. | Generic Semantic Configuration Service |
US9710238B2 (en) * | 2015-03-26 | 2017-07-18 | IfWizard Corporation | Automatically optimizing analytics database server |
US9477446B1 (en) * | 2015-03-31 | 2016-10-25 | Toyota Jidosha Kabushiki Kaisha | Bottom-up approach for integrating models for software components using contracts |
US9952837B1 (en) | 2015-04-01 | 2018-04-24 | The Mathworks, Inc. | Reusable component in a modeling environment |
US10303441B2 (en) | 2015-04-28 | 2019-05-28 | Nadia Analía Huebra | Process and system for automatic generation of functional architecture documents and software design and analysis specification documents from natural language |
US10831449B2 (en) | 2015-04-28 | 2020-11-10 | Lexica S.A.S. | Process and system for automatic generation of functional architecture documents and software design and analysis specification documents from natural language |
US10521209B2 (en) | 2015-05-12 | 2019-12-31 | Phase Change Software Llc | Machine-based normalization of machine instructions |
WO2016181368A1 (en) * | 2015-05-13 | 2016-11-17 | Huebra Nadia Analía | Method implemented by a computer that presents software-type applications based on design specifications |
US20160350081A1 (en) | 2015-05-27 | 2016-12-01 | Runnable Inc. | Automatic container definition |
US9582268B2 (en) * | 2015-05-27 | 2017-02-28 | Runnable Inc. | Automatic communications graphing for a source application |
US10884997B2 (en) * | 2015-06-10 | 2021-01-05 | International Business Machines Corporation | Maintaining a master schema |
EP3106897A1 (en) * | 2015-06-19 | 2016-12-21 | Centre National d'Etudes Spatiales | Gnss receiver with an on-board capability to implement an optimal error correction mode |
EP3115898B1 (en) * | 2015-07-06 | 2022-06-15 | Intuilab | Method for generating user-level events for an application |
US10366083B2 (en) | 2015-07-29 | 2019-07-30 | Oracle International Corporation | Materializing internal computations in-memory to improve query performance |
US10204135B2 (en) | 2015-07-29 | 2019-02-12 | Oracle International Corporation | Materializing expressions within in-memory virtual column units to accelerate analytic queries |
IN2015CH03905A (en) * | 2015-07-30 | 2015-08-14 | Wipro Ltd | |
US10346140B2 (en) | 2015-08-05 | 2019-07-09 | General Electric Company | System and method for model based technology and process for safety-critical software development |
US9720652B2 (en) | 2015-08-06 | 2017-08-01 | Symphore, LLC | Generating a software complex using superordinate design input |
WO2017027360A1 (en) | 2015-08-07 | 2017-02-16 | Fairwayiq, Inc. | System and method for managing and interacting with patrons at an activity venue |
US9898261B1 (en) * | 2015-09-30 | 2018-02-20 | Open Text Corporation | Method and system for configuring processes of software applications using activity fragments |
US10257275B1 (en) | 2015-10-26 | 2019-04-09 | Amazon Technologies, Inc. | Tuning software execution environments using Bayesian models |
US9891890B2 (en) | 2015-11-09 | 2018-02-13 | Microsoft Technology Licensing, Llc | Generation of an application from template |
US9940222B2 (en) | 2015-11-20 | 2018-04-10 | General Electric Company | System and method for safety-critical software automated requirements-based test case generation |
US9852053B2 (en) * | 2015-12-08 | 2017-12-26 | Google Llc | Dynamic software inspection tool |
JP2017107377A (en) * | 2015-12-09 | 2017-06-15 | 株式会社リコー | Apparatus management device, apparatus management system, verification method and program |
US9747085B2 (en) * | 2015-12-11 | 2017-08-29 | Paypal, Inc. | Source code generation from prototype source |
US20170168792A1 (en) * | 2015-12-15 | 2017-06-15 | Futurewei Technologies, Inc. | Space and time aware organization and isolation of components in real time systems |
KR101731629B1 (en) | 2015-12-24 | 2017-05-02 | 고려대학교 산학협력단 | Method and device for automatic generating go code from circus |
US11593342B2 (en) | 2016-02-01 | 2023-02-28 | Smartshift Technologies, Inc. | Systems and methods for database orientation transformation |
US10025696B2 (en) | 2016-02-09 | 2018-07-17 | General Electric Company | System and method for equivalence class analysis-based automated requirements-based test case generation |
GB2547220A (en) | 2016-02-10 | 2017-08-16 | Testplant Europe Ltd | Method of, and apparatus for, testing computer hardware and software |
GB2547222A (en) | 2016-02-10 | 2017-08-16 | Testplant Europe Ltd | Method of, and apparatus for, testing computer hardware and software |
US20170242668A1 (en) * | 2016-02-24 | 2017-08-24 | Microsoft Technology Licensing, Llc | Content publishing |
JP6620609B2 (en) * | 2016-03-09 | 2019-12-18 | 富士通株式会社 | Distributed processing execution management program, distributed processing execution management method, and distributed processing execution management device |
CN107229616B (en) * | 2016-03-25 | 2020-10-16 | 阿里巴巴集团控股有限公司 | Language identification method, device and system |
US10587708B2 (en) | 2016-03-28 | 2020-03-10 | Microsoft Technology Licensing, Llc | Multi-modal conversational intercom |
US11487512B2 (en) * | 2016-03-29 | 2022-11-01 | Microsoft Technology Licensing, Llc | Generating a services application |
US11100449B1 (en) * | 2016-04-05 | 2021-08-24 | Jpmorgan Chase Bank, N.A. | Systems and methods for efficiency management |
US11295229B1 (en) | 2016-04-19 | 2022-04-05 | Amazon Technologies, Inc. | Scalable generation of multidimensional features for machine learning |
US10713015B2 (en) | 2016-05-15 | 2020-07-14 | Servicenow, Inc. | Visual programming system |
US10394552B2 (en) * | 2016-05-17 | 2019-08-27 | Dropbox, Inc. | Interface description language for application programming interfaces |
US10585655B2 (en) | 2016-05-25 | 2020-03-10 | Smartshift Technologies, Inc. | Systems and methods for automated retrofitting of customized code objects |
US10719188B2 (en) | 2016-07-21 | 2020-07-21 | Palantir Technologies Inc. | Cached database and synchronization system for providing dynamic linked panels in user interface |
US10324609B2 (en) * | 2016-07-21 | 2019-06-18 | Palantir Technologies Inc. | System for providing dynamic linked panels in user interface |
US10528607B2 (en) * | 2016-07-29 | 2020-01-07 | Splunk Inc. | Syntax templates for coding |
US10089103B2 (en) | 2016-08-03 | 2018-10-02 | Smartshift Technologies, Inc. | Systems and methods for transformation of reporting schema |
US10521502B2 (en) * | 2016-08-10 | 2019-12-31 | International Business Machines Corporation | Generating a user interface template by combining relevant components of the different user interface templates based on the action request by the user and the user context |
JP2019526342A (en) | 2016-08-30 | 2019-09-19 | ライフセル コーポレーションLifeCell Corporation | System and method for controlling medical devices |
US10324908B2 (en) * | 2016-09-01 | 2019-06-18 | Sap Se | Exposing database artifacts |
US10893011B2 (en) * | 2016-09-13 | 2021-01-12 | Gluru Limited | Semantic interface definition language for action discovery in cloud services and smart devices |
US10120665B1 (en) | 2016-09-29 | 2018-11-06 | Amazon Technologies, Inc. | Latency-aware host-agnostic runtime |
MX2019004025A (en) | 2016-10-05 | 2019-08-05 | Walmart Apollo Llc | Systems and methods for synchronizing database schema. |
US10372443B2 (en) * | 2016-10-18 | 2019-08-06 | Oracle International Corporation | Multi-platform pattern-based user interfaces |
US10331415B2 (en) * | 2016-11-08 | 2019-06-25 | International Business Machines Corporation | Formal specification generation using examples |
US10545731B1 (en) | 2016-12-02 | 2020-01-28 | The Mathworks, Inc. | Variant modeling elements in graphical programs |
US10326864B2 (en) * | 2017-02-15 | 2019-06-18 | Sap Se | Dynamic orchestration of microservices |
CN106997378B (en) * | 2017-03-13 | 2020-05-15 | 上海摩库数据技术有限公司 | Redis-based database data aggregation synchronization method |
CA2999581A1 (en) | 2017-03-28 | 2018-09-28 | Walmart Apollo, Llc | Systems and methods for computer assisted database change documentation |
US10929759B2 (en) * | 2017-04-06 | 2021-02-23 | AIBrain Corporation | Intelligent robot software platform |
US11151992B2 (en) | 2017-04-06 | 2021-10-19 | AIBrain Corporation | Context aware interactive robot |
US10963493B1 (en) | 2017-04-06 | 2021-03-30 | AIBrain Corporation | Interactive game with robot system |
US10275225B1 (en) * | 2017-05-04 | 2019-04-30 | Amazon Technologies, Inc. | Implicit value store mapping |
US10379825B2 (en) * | 2017-05-22 | 2019-08-13 | Ab Initio Technology Llc | Automated dependency analyzer for heterogeneously programmed data processing system |
US10460044B2 (en) * | 2017-05-26 | 2019-10-29 | General Electric Company | Methods and systems for translating natural language requirements to a semantic modeling language statement |
US10466979B1 (en) * | 2017-06-01 | 2019-11-05 | Nationwide Mutual Insurance Company | Software requirements creating and tracking system and method |
CN109002279A (en) * | 2017-06-01 | 2018-12-14 | 如如研创股份有限公司 | The generation system of automated software |
US10705868B2 (en) * | 2017-08-07 | 2020-07-07 | Modelop, Inc. | Dynamically configurable microservice model for data analysis using sensors |
US10929384B2 (en) | 2017-08-16 | 2021-02-23 | Walmart Apollo, Llc | Systems and methods for distributed data validation |
US10877735B1 (en) | 2017-09-25 | 2020-12-29 | Amazon Technologies, Inc. | Automated generation of software applications using analysis of submitted content items |
US10691426B2 (en) * | 2017-10-26 | 2020-06-23 | Saudi Arabian Oil Company | Building flexible relationships between reusable software components and data objects |
US10521202B2 (en) * | 2017-11-20 | 2019-12-31 | Coupa Software Incorporated | Customizable project and help building interfaces for deployable software |
US10331421B2 (en) * | 2017-11-30 | 2019-06-25 | International Business Machines Corporation | Execution of a composite template to provision a composite of software service instances |
US10331419B2 (en) * | 2017-11-30 | 2019-06-25 | International Business Machines Corporation | Creating composite templates for service instances |
US11055134B2 (en) | 2017-11-30 | 2021-07-06 | International Business Machines Corporation | Performing an action on a composite of software instances |
US10705805B1 (en) | 2017-12-12 | 2020-07-07 | Amazon Technologies, Inc. | Application authoring using web-of-sheets data model |
JP6940831B2 (en) * | 2018-01-10 | 2021-09-29 | 日本電気株式会社 | Decision device, decision method, and decision program |
US10740075B2 (en) | 2018-02-06 | 2020-08-11 | Smartshift Technologies, Inc. | Systems and methods for code clustering analysis and transformation |
US10698674B2 (en) | 2018-02-06 | 2020-06-30 | Smartshift Technologies, Inc. | Systems and methods for entry point-based code analysis and transformation |
US10528343B2 (en) | 2018-02-06 | 2020-01-07 | Smartshift Technologies, Inc. | Systems and methods for code analysis heat map interfaces |
US10915307B2 (en) | 2018-02-22 | 2021-02-09 | Cisco Technology, Inc. | Automatically producing software images |
US10664294B2 (en) * | 2018-02-28 | 2020-05-26 | Intuit Inc. | Matching adopting users and contributing users for decentralized software localization |
JP7036205B2 (en) * | 2018-05-07 | 2022-03-15 | 日本電気株式会社 | System configuration derivation device and system configuration derivation method |
US11586603B1 (en) | 2018-05-23 | 2023-02-21 | Amazon Technologies, Inc. | Index sheets for robust spreadsheet-based applications |
US10586362B2 (en) * | 2018-06-18 | 2020-03-10 | Microsoft Technology Licensing, Llc | Interactive layout-aware construction of bespoke charts |
WO2019246630A1 (en) * | 2018-06-22 | 2019-12-26 | Otsuka America Pharmaceutical Inc. | Application programming interface using digital templates to extract information from multiple data sources |
US11226955B2 (en) | 2018-06-28 | 2022-01-18 | Oracle International Corporation | Techniques for enabling and integrating in-memory semi-structured data and text document searches with in-memory columnar query processing |
US20200042290A1 (en) * | 2018-08-02 | 2020-02-06 | Arcare Innova Corp. | BOM (bill-of-material)-Based Structured Specification Generating Method |
US10783063B2 (en) * | 2018-10-23 | 2020-09-22 | Salesforce.Com, Inc. | Systems and methods for testing a customer environment |
US10719304B2 (en) | 2018-11-16 | 2020-07-21 | Fujitsu Limited | Computer program generation using a library |
US10754626B2 (en) | 2018-11-30 | 2020-08-25 | Shopify Inc. | Visual and code views in a process workflow user interface |
CN109726213B (en) * | 2018-12-10 | 2021-11-19 | 阿里巴巴(中国)有限公司 | Program code conversion method, device, medium and computing equipment |
US20200184043A1 (en) * | 2018-12-11 | 2020-06-11 | Avago Technologies International Sales Pte. Limited | Multimedia content recognition with local and cloud-assisted machine learning |
WO2020139379A1 (en) * | 2018-12-28 | 2020-07-02 | LunaPBC | Community data aggregation, completion, correction, and use |
US10860295B1 (en) * | 2019-01-03 | 2020-12-08 | Amazon Technologies, Inc. | Automated detection of ambiguities in software design diagrams |
US10901729B2 (en) * | 2019-03-20 | 2021-01-26 | Visa International Service Association | System and method for merging specification files for an application programming interface |
US11681504B1 (en) | 2019-04-26 | 2023-06-20 | Opturo, Inc. | Automated application builder using configuration files |
CN110175019B (en) * | 2019-06-04 | 2021-11-16 | 南京大学 | Interrupt driving system verification method based on interrupt sequence diagram |
US10649745B1 (en) | 2019-06-10 | 2020-05-12 | Capital One Services, Llc | User interface common components and scalable integrable reusable isolated user interface |
US10698704B1 (en) * | 2019-06-10 | 2020-06-30 | Captial One Services, Llc | User interface common components and scalable integrable reusable isolated user interface |
CN112230909B (en) * | 2019-07-15 | 2023-05-23 | 腾讯科技(深圳)有限公司 | Method, device, equipment and storage medium for binding data of applet |
US10956134B2 (en) * | 2019-08-02 | 2021-03-23 | Sap Se | Itemization of rule branch condition expressions |
US11036478B2 (en) * | 2019-08-07 | 2021-06-15 | Sap Se | Automated determination of transformation objects |
US11188311B2 (en) | 2019-09-30 | 2021-11-30 | Microsoft Technology Licensing, Llc | Automated software generation through mutation and artificial selection |
US11113186B1 (en) * | 2019-12-13 | 2021-09-07 | Amazon Technologies, Inc. | Testing and publishing of resource handlers in a cloud environment |
US11144314B2 (en) | 2020-01-17 | 2021-10-12 | Accenture Global Solutions Limited | Systems and methods for software documentation and code generation management |
US11269694B2 (en) | 2020-03-03 | 2022-03-08 | The Toronto-Dominion Bank | Automated API code generation |
US11210285B2 (en) | 2020-03-06 | 2021-12-28 | Ab Initio Technology Llc | Generation of optimized logic from a schema |
US11829689B1 (en) | 2020-06-09 | 2023-11-28 | The Mathworks, Inc. | Systems and methods for creating variant regions in acausal simulation models |
US11580797B2 (en) | 2020-09-14 | 2023-02-14 | Toyota Research Institute, Inc. | Systems and methods for monitoring specifications over simulation and test data |
US11797541B1 (en) | 2020-10-23 | 2023-10-24 | State Farm Mutual Automobile Insurance Company | Systems and methods for enhanced rules conflict checking with data validation |
US11256493B1 (en) | 2020-11-03 | 2022-02-22 | Bank Of America Corporation | Container image optimizer |
US11429353B1 (en) * | 2020-12-09 | 2022-08-30 | Amazon Technologies, Inc. | Dynamic service provisioning using templatized infrastructure resources |
JP2024501045A (en) * | 2020-12-28 | 2024-01-10 | テンパー システムズ、インコーポレイテッド | Creation of idiomatic software documentation for many programming languages from common specifications |
US20220327012A1 (en) * | 2021-04-08 | 2022-10-13 | Dell Products L.P. | Software validation framework |
US11693652B2 (en) | 2021-04-16 | 2023-07-04 | 27 Software U.S. Inc. | Automated authoring of software solutions from a data model |
US11409505B1 (en) * | 2021-04-16 | 2022-08-09 | 27 Software U.S. Inc. | Automated authoring of software solutions from a data model with related patterns |
WO2022218549A1 (en) * | 2021-04-16 | 2022-10-20 | Huawei Technologies Co., Ltd. | Apparatus and method for generating requirement specifications |
US11675582B2 (en) | 2021-07-15 | 2023-06-13 | Kyndryl, Inc. | Neural networks to identify source code |
US11520463B1 (en) * | 2021-08-09 | 2022-12-06 | Tableau Software, LLC | Validating relationships between classes in object models |
US20230126702A1 (en) * | 2021-10-26 | 2023-04-27 | Sap Se | Transport of master data dependent customizations |
US11704233B2 (en) * | 2021-11-22 | 2023-07-18 | International Business Machines Corporation | Shift left model execution in software delivery |
US11416494B1 (en) | 2022-01-28 | 2022-08-16 | People Center, Inc. | Providing triggers based on one-to-many or many-to-one relationships in a system of record |
US20230315412A1 (en) * | 2022-03-30 | 2023-10-05 | Microsoft Technology Licensing, Llc | Scalable behavioral interface specification checking |
KR20240001943A (en) * | 2022-06-28 | 2024-01-04 | 황수진 | Automatic programming system and method using programming model |
Family Cites Families (55)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US4841441A (en) | 1984-08-01 | 1989-06-20 | Adata Software Limited | Method of creating a computer system |
US5371895A (en) | 1985-10-08 | 1994-12-06 | The Foxboro Company | Local equipment controller for computerized process control applications utilizing language structure templates in a hierarchical organization and method of operating the same |
US4734854A (en) | 1985-10-08 | 1988-03-29 | American Telephone And Telegraph Company | System for generating software source code components |
JPH0619715B2 (en) * | 1987-12-03 | 1994-03-16 | シャープ株式会社 | Question answering device |
IN170793B (en) | 1987-12-18 | 1992-05-23 | Hitachi Ltd | |
JP2624753B2 (en) | 1988-03-18 | 1997-06-25 | 株式会社日立製作所 | How to create higher-level specifications |
ES2017029A6 (en) * | 1989-07-26 | 1990-12-16 | Erana Agustin Arana | Core collecting tray provided with an in-built clipping system and adjustable cross travel allowing the core to be centered with the manipulator shaft |
DE69033120T2 (en) | 1989-09-01 | 1999-10-21 | Amdahl Corp | Operating system and database with an access structure made up of several tables |
DE3935627A1 (en) * | 1989-10-26 | 1991-05-02 | Schlafhorst & Co W | CONNECTING SYSTEM BETWEEN A SPINDING MACHINE AND A WINDING MACHINE |
US5159687A (en) * | 1989-11-14 | 1992-10-27 | Caseworks, Inc. | Method and apparatus for generating program code files |
US5204939A (en) * | 1989-12-14 | 1993-04-20 | Fujitsu Limited | Rule base processing system and rule evaluation control method therein |
US5603018A (en) | 1991-07-15 | 1997-02-11 | Mitsubishi Denki Kabushiki Kaisha | Program developing system allowing a specification definition to be represented by a plurality of different graphical, non-procedural representation formats |
US5485601A (en) | 1992-05-14 | 1996-01-16 | Ching; Hugh | Completely automated and self-generating software system |
JP3181994B2 (en) | 1992-09-03 | 2001-07-03 | 株式会社日立製作所 | How to automatically create job flow specifications |
US5640576A (en) | 1992-10-02 | 1997-06-17 | Fujitsu Limited | System for generating a program using the language of individuals |
US5742827A (en) | 1992-11-02 | 1998-04-21 | Fujitsu Limited | Method of automatically forming program specifications and apparatus therefor |
US5353401A (en) * | 1992-11-06 | 1994-10-04 | Ricoh Company, Ltd. | Automatic interface layout generator for database systems |
JPH06308918A (en) * | 1993-04-21 | 1994-11-04 | Fujitsu Ltd | Control method for displaying screen and control device for displaying screen |
JPH06332710A (en) * | 1993-05-21 | 1994-12-02 | Fujitsu Ltd | Object directional data processing system |
US5758160A (en) | 1993-06-28 | 1998-05-26 | Object Technology Licensing Corporation | Method and apparatus for building a software program using dependencies derived from software component interfaces |
CA2124624C (en) * | 1993-07-21 | 1999-07-13 | Eric A. Bier | User interface having click-through tools that can be composed with other tools |
CA2124505C (en) * | 1993-07-21 | 2000-01-04 | William A. S. Buxton | User interface having simultaneously movable tools and cursor |
WO1995003586A1 (en) * | 1993-07-21 | 1995-02-02 | Persistence Software, Inc. | Method and apparatus for generation of code for mapping relational data to objects |
US5581670A (en) * | 1993-07-21 | 1996-12-03 | Xerox Corporation | User interface having movable sheet with click-through tools |
US5842205A (en) | 1993-12-02 | 1998-11-24 | Vie Systems, Inc. | Method and process of inter-machine communication and generalized method for program preparation therefor |
US5875331A (en) * | 1994-09-30 | 1999-02-23 | International Business Machines Corp. | System and method for generating target language code utilizing an object oriented code generator |
JPH08234975A (en) * | 1995-02-28 | 1996-09-13 | Fujitsu Ltd | Program generation device and method |
JPH08255075A (en) * | 1995-03-17 | 1996-10-01 | Fujitsu Ltd | Software design support device supporting task division |
US5805891A (en) | 1995-07-26 | 1998-09-08 | International Business Machines Corporation | System and method for managing maintenance of computer software |
JPH09212352A (en) | 1996-01-31 | 1997-08-15 | Hitachi Software Eng Co Ltd | Program development support system |
US5742754A (en) | 1996-03-05 | 1998-04-21 | Sun Microsystems, Inc. | Software testing apparatus and method |
US6275976B1 (en) * | 1996-03-15 | 2001-08-14 | Joseph M. Scandura | Automated method for building and maintaining software including methods for verifying that systems are internally consistent and correct relative to their specifications |
US6877153B2 (en) * | 1996-04-10 | 2005-04-05 | Paul M. Konnersman | Computer-based system for work processes that consist of interdependent decisions involving one or more participants |
US5960200A (en) * | 1996-05-03 | 1999-09-28 | I-Cube | System to transition an enterprise to a distributed infrastructure |
US6434598B1 (en) * | 1996-07-01 | 2002-08-13 | Sun Microsystems, Inc. | Object-oriented system, method and article of manufacture for a client-server graphical user interface (#9) framework in an interprise computing framework system |
US6385765B1 (en) * | 1996-07-02 | 2002-05-07 | The Research Foundation | Specification and verification for concurrent systems with graphical and textual editors |
US6058493A (en) | 1997-04-15 | 2000-05-02 | Sun Microsystems, Inc. | Logging and reproduction of automated test operations for computing systems |
US5966534A (en) | 1997-06-27 | 1999-10-12 | Cooke; Laurence H. | Method for compiling high level programming languages into an integrated processor with reconfigurable logic |
US5995736A (en) * | 1997-07-24 | 1999-11-30 | Ati Technologies, Inc. | Method and system for automatically modelling registers for integrated circuit design |
US6289502B1 (en) * | 1997-09-26 | 2001-09-11 | Massachusetts Institute Of Technology | Model-based software design and validation |
KR100269258B1 (en) * | 1997-10-21 | 2000-10-16 | 정선종 | Integrated CASE Information Repository Metamodel System for Process Methodology and its Integration Support Method |
US5956725A (en) | 1997-11-26 | 1999-09-21 | Interanational Business Machines Corporation | Schema mapping to a legacy table with primary and foreign key support |
US6618852B1 (en) * | 1998-09-14 | 2003-09-09 | Intellichem, Inc. | Object-oriented framework for chemical-process-development decision-support applications |
US6393456B1 (en) * | 1998-11-30 | 2002-05-21 | Microsoft Corporation | System, method, and computer program product for workflow processing using internet interoperable electronic messaging with mime multiple content type |
US6199195B1 (en) * | 1999-07-08 | 2001-03-06 | Science Application International Corporation | Automatically generated objects within extensible object frameworks and links to enterprise resources |
US6571232B1 (en) * | 1999-11-01 | 2003-05-27 | Sun Microsystems, Inc. | System and method for browsing database schema information |
AU2001227857A1 (en) * | 2000-01-14 | 2001-07-24 | Saba Software, Inc. | Method and apparatus for a business applications management system platform |
US7334216B2 (en) * | 2000-04-04 | 2008-02-19 | Sosy, Inc. | Method and apparatus for automatic generation of information system user interfaces |
US6681383B1 (en) * | 2000-04-04 | 2004-01-20 | Sosy, Inc. | Automatic software production system |
US6850922B1 (en) * | 2000-07-14 | 2005-02-01 | International Business Machines Corporation | Business logic support |
US6721807B2 (en) * | 2000-08-10 | 2004-04-13 | International Business Machines Corporation | Extensible and efficient double dispatch in single-dispatch object-oriented programming languages |
JP3892685B2 (en) * | 2001-07-26 | 2007-03-14 | 株式会社東芝 | Helical antenna and portable terminal device |
US7155439B2 (en) * | 2001-09-20 | 2006-12-26 | Wellogix, Inc. | Modular and customizable process and system for capturing field documentation data in a complex project workflow system |
US7032210B2 (en) * | 2001-11-11 | 2006-04-18 | International Business Machines Corporation | Method and system for generating program source code of a computer application from an information model |
JP4157071B2 (en) * | 2004-03-31 | 2008-09-24 | 大日本印刷株式会社 | Resin for forming receptor layer of thermal transfer image receiving sheet and thermal transfer image receiving sheet using the same |
-
2000
- 2000-04-04 US US09/543,085 patent/US6681383B1/en not_active Expired - Lifetime
-
2001
- 2001-03-02 AU AU4194501A patent/AU4194501A/en active Pending
- 2001-03-02 CA CA2723005A patent/CA2723005A1/en not_active Abandoned
- 2001-03-02 CA CA2403975A patent/CA2403975C/en not_active Expired - Fee Related
- 2001-03-02 AU AU2001241945A patent/AU2001241945B2/en not_active Ceased
- 2001-03-02 JP JP2001573206A patent/JP2004506962A/en active Pending
- 2001-03-02 WO PCT/US2001/006790 patent/WO2001075593A2/en active IP Right Grant
- 2001-03-02 EP EP01913266A patent/EP1272927A2/en not_active Ceased
- 2001-06-01 US US09/872,333 patent/US7137100B2/en not_active Expired - Fee Related
- 2001-06-01 US US09/872,087 patent/US20030167455A1/en not_active Abandoned
- 2001-06-01 US US09/872,413 patent/US7278130B2/en not_active Expired - Fee Related
-
2004
- 2004-06-24 US US10/877,492 patent/US8141031B2/en not_active Expired - Fee Related
-
2006
- 2006-10-04 US US11/542,827 patent/US7555742B2/en not_active Expired - Fee Related
- 2006-10-05 US US11/543,426 patent/US7584451B2/en not_active Expired - Fee Related
- 2006-10-10 US US11/545,438 patent/US8037449B2/en not_active Expired - Fee Related
-
2007
- 2007-04-18 JP JP2007109887A patent/JP2007257654A/en not_active Withdrawn
-
2008
- 2008-09-25 US US12/284,842 patent/US8245183B2/en not_active Expired - Fee Related
- 2008-09-26 US US12/284,947 patent/US8365138B2/en not_active Expired - Fee Related
-
2009
- 2009-03-18 JP JP2009066293A patent/JP2009193592A/en active Pending
Cited By (5)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US10552540B2 (en) | 2017-11-27 | 2020-02-04 | International Business Machines Corporation | Automated application composer with natural language processing |
US11429791B2 (en) | 2017-11-27 | 2022-08-30 | International Business Machines Corporation | Automated application composer with natural language processing |
WO2019113308A1 (en) * | 2017-12-05 | 2019-06-13 | Franchitti Jean Claude | Active adaptation of networked compute devices using vetted reusable software components |
US10338913B2 (en) | 2017-12-05 | 2019-07-02 | Archemy, Inc. | Active adaptation of networked compute devices using vetted reusable software components |
US11074061B2 (en) | 2017-12-05 | 2021-07-27 | Archemy, Inc. | Active adaptation of networked compute devices using vetted reusable software and hardware components |
Also Published As
Publication number | Publication date |
---|---|
US20080209391A1 (en) | 2008-08-28 |
US7278130B2 (en) | 2007-10-02 |
WO2001075593A3 (en) | 2002-08-08 |
JP2009193592A (en) | 2009-08-27 |
CA2403975A1 (en) | 2001-10-11 |
US7584451B2 (en) | 2009-09-01 |
US20040233232A1 (en) | 2004-11-25 |
US20090125546A1 (en) | 2009-05-14 |
AU2001241945B2 (en) | 2004-11-11 |
US20070089103A1 (en) | 2007-04-19 |
JP2007257654A (en) | 2007-10-04 |
US7555742B2 (en) | 2009-06-30 |
WO2001075593A2 (en) | 2001-10-11 |
US8245183B2 (en) | 2012-08-14 |
EP1272927A2 (en) | 2003-01-08 |
US7137100B2 (en) | 2006-11-14 |
US20020100014A1 (en) | 2002-07-25 |
CA2403975C (en) | 2012-05-01 |
AU4194501A (en) | 2001-10-15 |
US8141031B2 (en) | 2012-03-20 |
US20090132995A1 (en) | 2009-05-21 |
US20030167455A1 (en) | 2003-09-04 |
WO2001075593A9 (en) | 2003-07-10 |
JP2004506962A (en) | 2004-03-04 |
US8365138B2 (en) | 2013-01-29 |
US20020062475A1 (en) | 2002-05-23 |
US20070168907A1 (en) | 2007-07-19 |
US6681383B1 (en) | 2004-01-20 |
US8037449B2 (en) | 2011-10-11 |
Similar Documents
Publication | Publication Date | Title |
---|---|---|
CA2403975C (en) | Automatic software production system | |
AU2001241945A1 (en) | Automatic software production system | |
US7941438B2 (en) | Method and apparatus for automatic generation of information system user interfaces | |
Meyer | Lessons from the design of the Eiffel libraries | |
Torre et al. | A systematic identification of consistency rules for UML diagrams | |
JP2009193592A5 (en) | ||
US7448028B2 (en) | System and method for selective local object retrieval | |
Porres | A toolkit for model manipulation | |
Cesal | Interoperability of Metamodeling Frameworks | |
Wei | An extensible static analysis framework for automated analysis, validation and performance improvement of model management programs | |
Griebel | Repository Support for Visualization in Relational Databases | |
Larson et al. | KBSA framework | |
Fadini et al. | PROGETIO FINALIZZATO SISTEMI INFORMATICI E CALCOLO PARALLELO SOTIOPROGETIO 6 Metodi e Strumenti per la Progettazione di Sistemi | |
Deliège | THESIS/THÈSE | |
Tibrea et al. | Enriching EMF models with behavioral specifications | |
Admal | Object oriented modeling and rapid prototyping of information systems | |
Guide | Red Hat Web Application Framework 6.0 | |
Reddy | An approach to composing aspect-oriented design models | |
Hameed | Malicious Email Detection & Filtering System Using Bayesian Machine Learning Algorithm | |
Tamás | Erlang kód tárolása adatbázisban | |
Golitsinski | Specification and Automatic Code Generation of the Data Layer for Data-intensive Web-based Applications | |
Ledeczi et al. | Framework for the Rapid Development of Modeling Environments | |
Sagar | Feature-Oriented Decomposition of SQL: 2003 |
Legal Events
Date | Code | Title | Description |
---|---|---|---|
EEER | Examination request | ||
FZDE | Discontinued |
Effective date: 20151223 |