WO2003081427A1

WO2003081427A1 - Knowledge re-use system

Info

Publication number: WO2003081427A1
Application number: PCT/JP2003/003535
Authority: WO
Inventors: Tomio Iizuka
Original assignee: Duo Systems Co., Ltd.
Priority date: 2002-03-25
Filing date: 2003-03-24
Publication date: 2003-10-02
Also published as: AU2003221016A1; JP2003280900A; JP4154164B2

Abstract

A knowledge re-use system for re-using an existing program for developing a program and supporting the development. The knowledge re-use system automatically generates a model of a program executable on a computer. The knowledge re-use system includes interface formalization means for generating electronic knowledge for reading a program and/or a database and having physical characteristic and logical characteristic of public information in the program and/or database which have been read in and program means for automatically generating a model of an executable program according to the electronic knowledge generated, a program generation method definition specified by a developer performing the automatic generation of the model of the executable program, and at least one generation method predetermined for automatic generation of a program.

Description

Description Knowledge reuse system Technical field

The present invention relates to a knowledge reuse system that reuses an existing program when developing the program and supports the development of the program. Background art

As programs have become more sophisticated and larger in recent years, there are development support tools such as CASE tools (Computer Aided Software Engineering) and IDE tools (Intergrated Development Environment) for developing programs. .

The CAS E tool is a development support tool that aims to streamline system development work among multiple programmers (hereinafter, developers). A typical example of the CALSE tool is a product sold by Nippon Rational Software Co., Ltd., which is named Ration1Rose.

The IDE Tool is a development support tool that aims to perform multiple development environments required for developing programs such as editors, compilers, and debuggers in one integrated development environment. A typical example of an IDE tool is Microsoft Co., Ltd.'s product, MicrososftVistualStudio.

By using these development support tools, it is possible to manage information limited to one of the logical and physical characteristics of the program, realizing the function of generating a program template.

In this specification, a physical feature is a variable, class, method, data, or the like in a program or database. 論理 Means that can be assigned, and the logical feature means that a variable, class, method, data, etc. can be characterized in relation to other variables, classes, methods, data, etc. Some of the physical features are associated with variables, methods, and so on.

However, even if the above development support tools are used, the method of expressing the logical and physical characteristics of the program components as a unit has not been realized, so business knowledge and program realization are not realized. It is not possible for a knowledge and a program to automatically and mutually utilize the knowledge of the program. In other words, in conventional development support tools, program templates are generated from either physical or logical features, so that features such as variables can be expressed only from one side (physical features or logical features). As a result, efficient and highly complete program templates have not been generated.

In addition, when the function to generate a program based on the physical characteristics of the program is incorporated, the specific method of generation is incorporated in the development support tool, and the generation method suitable for the program implementation method is changed. It is impossible for the developer to make any changes.

Furthermore, since the characteristics of the user interface cannot be described in the data items input / output through the program interface, the developer must manually create a program for the user interface in accordance with the program, and the Verification is difficult. Disclosure of the invention

Therefore, the present inventor has recorded the logical and physical characteristics of a program in a machine-readable and human-readable form, and independently recorded from a specific development tool or program. We have invented a knowledge reuse system that makes knowledge about knowledge (hereinafter referred to as “electronic knowledge”) interchangeable in all processes of program development, and generates templates from both physical and logical characteristics of variables and the like.

In the present invention, various generation methods based on computerized knowledge By separating the generation format from the development tools, it is possible to generate program parts (executable program templates) in most arbitrary programs by switching the generation format. Furthermore, since the digitized knowledge is human-readable, it can be created by directly describing the design and implementation methods of the program without using the face-to-face formalizing function. That is, it is possible to create and update computerized knowledge using an editor usually provided in a computer, and to design and create a template of an executable program.

The invention according to claim 1 is a knowledge reuse system that automatically generates a model of a program executable on a computer, and reads a program and / or a database, and reads the read program and / or ^ An interface formalizing means for generating digitized knowledge having physical and logical characteristics of public information in a database; and automatically generating the generated digitized knowledge and a template of an executable program. A program that automatically generates a template of the executable program based on a program generation method definition specified by a developer to be executed and at least one or more predetermined generation modes for automatically generating a program. And a knowledge reuse system having means.

According to the present invention, by reading at least one or more program Z databases, a developer can accumulate physical and logical characteristics of the public information as digitized knowledge. Then, based on the accumulated electronic knowledge, the developer specifies what program is necessary, and based on the physical and logical characteristics of the electronic knowledge, efficient and accurate Automatic generation of executable program templates becomes possible.

The invention according to claim 2 is characterized in that the interface formalizing means reads a source program and generates digitized knowledge having physical and logical characteristics of public information in the read source program. Use a knowledge reuse system with program interface formalization means. The invention according to claim 3 is characterized in that the interface formalizing means reads a target program, and generates electronic knowledge having physical and logical characteristics of public information in the read target program. This is a knowledge reuse system having a program interface formalization means.

The invention according to claim 4 is characterized in that the interface formatting means reads a database, and the electronic knowledge having physical and logical characteristics of the table view in the read database. Is a knowledge reuse system that has modeling information formalization means for generating the information. <According to the inventions of claims 2 to 4, those that can be stored as digitized knowledge include a human-readable source program, Machine-readable target programs and databases can be used. Here, the source program indicates a human-readable program such as the source code of the program, and the target program indicates a machine-readable program as a result of compiling the source code of the program. The invention according to claim 5 is characterized in that the program means includes at least a predetermined information for automatically generating the computerized knowledge generated by the interface formalizing means, the definition of the program generation method, and a template of an executable program. This is a knowledge reuse system that has program generation means for automatically generating a human-readable model of a program based on one or more generation modes.

According to the present invention, it is possible to automatically generate a human-readable program template based on computerized knowledge and at least a predetermined generation method (generation mode).

The invention according to claim 6 is a knowledge reuse system, wherein the program means has a purpose program generating means for converting a template of a human-readable program automatically generated by the program generating means into a machine-readable program.

According to the present invention, a template of an automatically generated program can be converted into a machine-readable format, and the developer can execute the converted executable program. All you have to do is use a simple program template.

The invention according to claim 7 is characterized in that the program generation means adds the digitized knowledge generated by the interface formalization means based on the correction generation style specified in the program generation method definition. And / or correction and / or aggregation to generate the solved digitized knowledge, and the solved digitized knowledge based on the verification generation style specified in the program generation method definition. Verifying means for verifying the program, and generating a program generation rule by applying the generation style for generation rule generation specified in the program generation method definition to the resolved digitized knowledge. Means, based on a program generation style specified in the program generation method definition and the generated program generation rules. A template generating means for generating a template of a readable program, and a generating rule for generating a configuration rule specified in the definition of the program generation method is applied to the resolved electronic knowledge to generate a program configuration rule. This is a knowledge reuse system having program configuration rule generation means.

It is rare that the accumulated electronic knowledge is complete from the beginning. Therefore, when using it, it is preferable to add corrections to the accumulated digitized knowledge according to the model of the program that the developer wants to automatically generate. It is also necessary to confirm whether the solved digitized knowledge generated by the addition is logically consistent. Therefore, if the verification is performed and the consistency is obtained, it is preferable to generate a program template based on the resolved electronic knowledge. According to the present invention, these items can be performed, and a template of a program with better accuracy can be automatically generated.

The invention according to claim 8 is a knowledge reuse system in which the program and the public information of the Z or the database include at least one of a variable, a class, a method, and a table'view. BRIEF DESCRIPTION OF THE FIGURES

FIG. 1 is a system configuration diagram showing an example of the system configuration of the present invention. FIG. 2 is a system configuration diagram showing an example of the system configuration of the present invention. FIG. 3 is a flowchart illustrating an example of a process flow of a source (objective) program interface formalizing process, and FIG. 4 is a flowchart illustrating an example of a process flow of an electronic knowledge processing. is there. FIG. 5 is a flowchart showing an example of a flow of a process of digitizing knowledge processing. FIG. 6 is a flowchart showing an example of a process flow of the electronic knowledge processing. FIG. 7 is a flowchart showing an example of a process flow of the modeling information formalizing process. FIG. 8 is a flowchart showing an example of the flow of the modeling information formalizing process. FIG. 9 is a flowchart showing an example of a process flow of a program generation process. FIG. 10 is a flowchart showing an example of a process flow of a program generation process. FIG. 11 is a flowchart illustrating an example of a process flow of a program generation process. FIG. 12 is a diagram showing an example of a source program. FIG. 13 is a diagram showing the state after the processing of the public variable. FIG. 14 is a diagram showing a state after the processing for the public method. FIG. 15 is a diagram showing another example of the public method after processing. FIG. 16 is a diagram showing another example of the public method after processing. FIG. 17 is a diagram showing another example of the public method after processing. FIG. 18 is a diagram showing a definition of a program generation method. FIG. 19 is a diagram showing digitized knowledge before additional correction. FIG. 20 is a diagram showing digitized knowledge after additional correction. FIG. 21 is a diagram showing computerized knowledge when a plurality of computerized knowledge are aggregated into one. FIG. 22 is a diagram showing the digitized knowledge after being aggregated into one digitized knowledge. Figure 23 is an example of a database. FIG. 24 is a diagram showing an example of digitized knowledge generated from a database. FIG. 25 shows an example of solved electronic knowledge. Figure 26 shows an example of a program generation rule. Brief description of the symbols

1: Knowledge reuse system 2: Interface formalization means 3: Program means 4: Electronic knowledge 5: Correction generation style 6: Verification generation style Ί: Generation rule generation style 8: Program generation style 9 : Forming rules for generating composition rules 10 0: Source program interface formalizing means 1 1: Objective program interface formalizing means 1 2: Modeling information formalizing means 1 3: Program generating means 1 4: Objective program generating means 1 5: Correction means 16: Verification means 17: Program generation rule generation means 18: Model generation means 19: Program composition rule generation means Best mode for carrying out the invention

An example of the system configuration of the embodiment of the present invention is shown in the system configuration diagram of FIG. The knowledge reuse system 1 has an interface formalization means 2, a program means 3, electronic knowledge 4, and at least one or more generation modes.

The interface formalizing means 2 is a means for extracting logical features and physical features from variables, classes, methods, database tables and views in a program, a database, and the like, and generating them as digitized knowledge 4. . The interface formalizing means 2 has a primitive program interface formalizing means 10, a target program interface formalizing means 11, and a modeling information formalizing means 12.

The source program interface formalizing means 10 is a means for extracting logical features and physical features from the source program and generating it as digitized knowledge 4. The source program is a human-readable program such as the source code of the program.

The purpose program interface formalizing means 1 extracts logical features and physical features from the goal program and converts them into electronic knowledge 4. It is a means for generating. The target program is a machine readable result of compiling the source code of the program. The modeling information formalizing means 1 2 is a means for extracting logical and physical characteristics from the database and generating it as digitized knowledge 4. Means for generating an end-purpose program as a final result (that is, a model of an automatically generated executable program which is machine-readable) based on chemical knowledge 4. Object program generating means 14.

The program generating means 13 is means for generating a modified program template and a program configuration rule based on the digitized knowledge 4 generated by the interface formalizing means 2. The template of the program generated here indicates a human-readable program, and the program configuration rules refer to the order in which the template of the generated program is compiled in the target program generating means 14 in any order. This is a rule that specifies whether to convert to readable.

The target program generating means 14 is a means for generating a machine-readable and executable final target program based on the template of the program generated in the program generating means 13 and the program configuration rules. That is, it indicates a compiler or the like.

The program generation means 13 includes a correction means 15, a verification means 16, a program generation rule generation means 17, a template generation means 18, and a program configuration rule generation means 19.

The correction means 15 is based on the correction generation format 5 in the program generation method definition specified by the developer, and the physical knowledge lacking in the computerized knowledge 4 generated in the interface formalization method 2 It is a means to add and correct the technical features and logical features, to collect multiple electronic knowledge 4 into one, and to modify the electronic knowledge 4. The added, modified, aggregated, and other digitized knowledge 4 is referred to as the resolved digitized knowledge. Here, the program generation method definition specified by the developer is defined as This is a code that defines whether you want to generate a simple program template (final purpose program). An example is shown in Fig. 18.

The verification means 16 is a means for verifying whether or not the solved digitized knowledge is logically compatible, based on the verification generation format 6 in the program generation method definition specified by the developer. It is.

The program generation rule generation means 17 is a means for applying the resolved computerized knowledge and generating a program generation rule based on the generation rule generation style 7 in the program generation method definition specified by the developer. It is.

Based on the program generation rules generated by the program generation rule generation means 17 and the program generation format 8 and the resolved electronic knowledge, the template generation means 18 This is a means for generating a human-readable model of a program by applying generation format 7.

The program configuration rule generation means 19 is configured to generate the converted electronic knowledge based on the configuration rule generation generation style 9 in the program generation method definition specified by the developer and the resolved electronic knowledge. This is a means for generating the program configuration rules by applying the configuration rule generation generation style 9 ₍ Next, an example of the process flow of the present invention will be described with reference to the flow charts of FIGS. This will be described in detail with reference to the diagram and the system configuration diagram shown in Fig. 2. First, an example of a flow of a process for generating the electronic information 4 from the source program, the target program, and the database will be described. An example of the process flow when generating digitized knowledge 4 from a program and a target program will be described with reference to the flowcharts in Fig. 3 to Fig. 6. The generation of digitized knowledge 4 for a source program is as follows. , In the source program interface formalizing means 10 of the interface formalizing means 2, the generation of computerized knowledge 4 for the target program is performed by the target program interface formalizing means 11 of the interface formalizing means 2. Each process is performed, but the process flow is almost the same. The case of a program will be described. Therefore, in the case of the target program, the processing can be performed by almost the same process in the target program input face formalizing means 11, but the description is omitted for simplification.

When it is desired to generate the digitized knowledge 4, the source program for generating the digitized knowledge 4 is converted to the source program of the interface re-formatting means 2 in the knowledge reuse system 1. It is read by the program interface formalizing means 10 (S100). Figure 12 shows the source program to be read here.

The source program interface face formatting means 10 that has read the source program acquires class information from the source program (S110). Therefore, in the case of FIG. 12, the class information of T e st C 1 a s s is obtained.

From the acquired class information, public information such as public variables and public methods contained therein is extracted (S120). Here, the public information indicates that the variables, methods, and the like in each class can be referred to from other classes and can be manipulated as a whole in the program. In the AVA language (JAVA is a registered trademark of Sun Microsystems, Inc .; and so forth), the pub1ic type indicates this. Therefore, for example, the method name of the primitive program shown in FIG. 12 such as setPropl.setProp2, the variable name of prop3, and the like are obtained.

The public information in the acquired class information is processed to be stored as digitized knowledge 4 (S130). This process will be described later.

The accumulation of digitized knowledge 4 in the classes S100 to S130 is repeated until all the class information in the source program is obtained (S

1400), accumulated from the source program as computerized knowledge 4. In this specification, since the JAVA language is taken as an example of a source program, processing is performed for each class. However, naturally, other object-oriented languages and object programs are used. For programming languages that do not use an oriented language, What is necessary is just to determine whether the process is completed.

Obtain an external file that defines the output format for saving the digitized knowledge 4 generated by repeating S 1 0 to S 1 4 0 (S 1 50), and based on the obtained definition format To output the digitized knowledge 4 (S160).

As described above, the processing in S110 and S120 is the process of extracting the physical features from the source program, and S130, which will be described later, performs logical processing based on the extracted physical features. This is the process of extracting features.

Next, the flow of the process of digitizing knowledge of public information in S130 will be described with reference to the flowcharts of FIGS.

Add the physical characteristics of the public variables in the classes extracted in S110 and S120 to the digitized knowledge attribute information table (S200), and an example of the source program in Fig. 12 Now, prop 3 is a public variable (pub 1 ic type), so we will add a physical feature to this variable. Fig. 13 (a) shows an example of adding the physical characteristics of the public variables in the source program in Fig. 12.

Based on the physical characteristics of the public variable added in S200, the logical characteristics (for example, the type of the variable) of the public variable are added to the electronic knowledge attribute information table (S210) ). An example of adding logical features is shown in Fig. 13 (b). In the example of Fig. 12, the physical feature is long type, so in the JAVA language, 1 ong type means double precision of integer type, so the logical feature is Long I nteger.

Based on the physical and logical features added in S200 and S210, the public variable can be obtained and whether the attribute value can be updated and obtained (That is, information indicating whether the method name can be referred to by a method name starting from set or a method name starting from get) is added to the computerized knowledge attribute information table (S220). An example in which S220 is added is shown in FIG. 13 (c). S 2 0 0 Then, the processing of S220 is performed for all the public variables in the class (S2300).

After the completion of the computerized knowledge processing for the public variables, the computerized knowledge processing for the public method (pu 1 ic type method) is performed. It is determined whether the public method name in the class starts with "set" and whether there is only one argument for the public method (S240), and if the condition is satisfied, the public method is determined. The attribute name is derived from the method name (S250). That is, in the source program shown in FIG. 12, the public method of setProp1 is extracted, and propl is derived from the public method as an attribute name. Fig. 14 (a) shows this example.

It is determined whether or not the attribute name derived in S250 exists in the digitized knowledge attribute information table (S260), and if not, the derived attribute name is digitized. Add to the knowledge attribute information table. Here, propl is not stored in the digitized knowledge attribute information table already stored as digitized knowledge 4 (only prop 3 is stored in the digitized knowledge attribute information table). Add propl as computerized knowledge 4.

The physical characteristics of the added public method are added to the digitized knowledge attribute information table (S270), and then a logical characteristic is created from the physical characteristics and added (S280). In the example of the source program shown in FIG. 12, the state shown in FIGS. 14 (b) and (c) is obtained. FIG. 14 (b) shows a state in which physical features are added, and FIG. 14 (c) shows a state in which logical features are added. All of these can be identified and added based on the types, arguments, return values, etc. of the public methods in the source program, in the same way as in the processing for public variables.

After the addition of the physical and logical features, the fact that attribute values can be updated is added to the digitized knowledge attribute information table (S290). In this way, through the process from S 240 to S 290, the accumulation of digitized knowledge 4 when the public method starts with set and there is only one argument Can be performed. FIG. 15 shows an example in which the same processing is performed on set Prop 2 of the source program shown in FIG.

Next, it is determined whether the public method name in the class starts with “get” and there is an argument (S300). If the condition is satisfied, the same as S240 to S290 is performed. The attribute name is derived from the public method name (S310), and it is determined whether the attribute name exists in the digitized knowledge attribute information table (S320), and if not, it must exist. For example, the physical and logical characteristics of the public method are added to the electronic knowledge attribute information table (S330, S340). In addition, the fact that the attribute value can be updated is added to the digitized knowledge attribute information table (S350). FIG. 16 shows an example in which the processing from S310 to S340 is performed on getPropl of the source program in FIG. However, for getProp 1, the attribute name prop 1 already exists in the digitized knowledge attribute information table, so the physical and logical features are not processed, and only updatable information is added. Becomes

Next, it is determined whether the public method name in the class starts with is, has no arguments, and the return value is a boolean type (S360), and if the condition is satisfied. , A process similar to that of S240 to S290 and S310 to S350 is performed. That is, an attribute name is derived from the public method name (S370), and it is determined whether or not the attribute name exists in the digitized knowledge attribute information table (S380). If not, the physical and logical characteristics of the public method are added to the digitized knowledge attribute information table (S390, S4'00). Also, the fact that the attribute value can be updated is added to the digitized knowledge attribute information table (S410).

The public method names in the class are S240, S300, S

If none of the conditions in 360 is met, the public method name is added to the digitized knowledge operation information table as an operation name (S

42 0). The public method do Something in the source program shown in Fig. 12 can be used for any of S240, S300, and S360. Since they do not match, the relevant public method name do Someme thing is added to the digitized knowledge operation information table as the operation name. An example of this case is shown in Fig. 17 (a).

The physical and logical characteristics of the public method (in this case, do Someme thing) added to the digitized knowledge operation information table are similarly added to the digitized knowledge operation information table (S430, S440) o An example of this case is shown in Fig. 17 (b) and (c). Fig. 17 (b) is an example of adding the physical and logical features of the input information in the public method do Something. Fig. 17 (c) is the public method do S This is an example of adding physical and logical characteristics of output information in om ething.

As described above, the process from S240 to S440 is repeated for all the public methods in the class (S450). In this way, it is possible to accumulate electronic knowledge 4 having physical and logical characteristics from a source program. That is, the digitized knowledge attribute information table and the digitized knowledge operation information table become the digitized knowledge 4. Also, in the present invention, get is added to the beginning of the method name as a method for transferring a variable or the like to another method, and the method name is obtained as a method for acquiring a variable or the like from the other method. Although set is added at the beginning of the file, it is preferable that this be set so that it can be arbitrarily set as a rule in the processing form of each program. Next, in the modeling information formalizing means 12 of the interface formalizing means 2, the flow of the process for accumulating the digitized knowledge 4 from the database will be described with reference to the flow charts of FIGS. 7 and 8. This will be explained in detail.

When it is desired to generate the digitized knowledge 4 from the database, the database from which the digitized knowledge 4 is generated is converted into the modeling information format of the interface formalizing means 2 in the knowledge reuse system 1. And read them into the means 1 and 2. Fig. 23 shows an example of a database table to be read here. The modeling information formatting means 12 that has read the database acquires the definition information of the designated table / view from the database (S500). In the example of Fig. 23, a table named DAT A-T ABLE from the database is specified by the developer as a processing target of electronic knowledge 4, so that the table DAT A-TABLE must be obtained. Become.

From the acquired specified table / view definition information, the column names contained therein are acquired (S510). In the example of FIG. 23, the columns PROP1, PR〇P2, and PROP3 are acquired. Therefore, a logical identifier is derived from the obtained table name and added to the digitized knowledge attribute information table (in this case, DataTabl e). The electronic knowledge attribute information table in this state is shown in Fig. 24 (a). At the same time, the table name is extracted as a physical feature and added to the digitized knowledge attribute information table. FIG. 24 (b) shows the digitized knowledge attribute information table in this state.

From each of the acquired columns, the physical characteristics in the columns are extracted and added to the digitized knowledge attribute information table (S520). Therefore, in Fig. 23, the column name, type, length, and integer precision are extracted as physical characteristics. For column PROP1, the column name is PROP1, the type is VARCHAR, the length is 256, and the precision is extracted as no data. An example of the digitized knowledge attribute information table in this state is shown in Fig. 24 (c).

The logical characteristics of the columns are derived from the acquired table / view definition information and added to the digitized knowledge attribute information table (S530). In Fig. 23, logical type, length, and vacant element tolerance information are derived and added as logical features. Therefore, the logical type is String (the physical characteristic type is VAR CHAR type, and VAR CHAR type generally means the string type), the length is 256, and the length is empty. No (not permitted) as element permission information. An example of the digitized knowledge attribute information table in this state is shown in Fig. 24 (d). You.

After acquiring physical and logical characteristics, unique constraint information is acquired from the definition information of the table and view (S540). If there is a unique constraint (S550), the digitized knowledge attribute information is acquired. Add it to the table (S560). In FIG. 23, since there is a unique constraint, a flag of “1” indicating that there is a unique constraint in the digitized knowledge attribute information table is set. An example of the digitized knowledge attribute information table in this state is shown in Fig. 24 (e). If there is no unique constraint, this information need not be added to the electronic knowledge attribute information table.

After adding unique constraint information to the digitized knowledge attribute information table, or when there is no unique constraint, whether the attribute value can be updated and acquired in the digitized knowledge attribute information table Is added to the digitized knowledge attribute information table (S570). In the case of FIG. 23, since the attribute values can be updated and obtained, they are added to the electronic knowledge attribute information table as described above. This is shown in Figure (f).

The processing from S520 to S570 is repeated for all the columns acquired in S510 (S580). FIGS. 24 (g) and 24 (h) show examples of processing on each column.

The output format specification file for outputting the computerized knowledge 4 generated in this way is read (S590), and the computerized knowledge 4 is output according to the read output format specification file (S600). ).

Next, based on the digitized knowledge 4 accumulated in S100 to S600, the flow of the process of generating a program using the knowledge is shown in the flow charts of FIGS. 9 to 11. This will be described in detail with reference to the system configuration diagrams of FIGS. 1 and 2.

If a program is generated based on the accumulated computerized knowledge 4 using that knowledge, it is unlikely that the stored computerized knowledge 4 is complete. This must be done first in the third correction method 15. For that, the developer A code (program generation method definition) that defines whether a template of an executable program is to be generated is specified or coded, and a correction generation format 5 (in this embodiment, R esolve Pattern (Composent. xsl) is obtained (S700). Figure 18 shows the program generation method definition. The correction generation format 5 adds and corrects physical and logical features, etc., that are missing from the accumulated electronic knowledge 4 to the accumulated electronic knowledge 4. In the case where the computerized knowledge 4 is referred to, a format for integrating the computerized knowledge 4 into one is stored.

First, the case of adding and modifying physical features, logical features, and the like to the digitized knowledge 4 will be described using the digitized knowledge 4 in FIGS. 19 and 20. Fig. 19 shows the digitized knowledge 4 before correction (digitized knowledge 4 created by the interface formalizing means 2), and Fig. 20 shows the correction means 15 as the digitized knowledge of Fig. 19 This is the corrected digitized knowledge 4 created as a result of adding and modifying 4.

The digitized knowledge 4 described in FIG. 19 lacks logical features such as nam e, ov er v i ew in the identifier of p rop 20. Therefore, for example, when adding the logical feature of the overview, the method of describing the overview in the correction generation format 5 acquired in S700 (the description such as O verviewofidentiferdat atype here) And "identifer" means to add the identifier described in the tag identifer, and "datatype" means to add the data type of the identifier described in the tag data Type.) However, the tag of the logical feature, "overview", is added. Similarly, for physical information, additional correction is performed with reference to correction generation format 5.

Next, the case where the electronic knowledge 4 refers to another electronic knowledge 4 and the correction means 15 for integrating the electronic knowledge 4 into one is performed. This is explained using knowledge 4. Fig. 21 (a) shows' Electrified knowledge 4 before aggregation, which refers to other electronic knowledge 4 (tag reference). FIGS. 21 (b) and (c) show the digitized knowledge 4 on the reference side, and FIG. 21 (b) shows Referenced—Probertyl and FIG. 21 (c) shows Referenced — P roperty 2.

Since the tag reference exists in the digitized knowledge 4 in Fig. 21 (a), the digitized knowledge 4 refers to R eferenced—P ropertyl and R eferenced—P roperty 2. Turns out. Therefore, the correction means 15 refers to the electronic knowledge 4 and reflects the electronic knowledge 4 in FIGS. 21 (b) and (c) to the electronic knowledge 4 in FIG. 21 (a). , But to one electronic knowledge 4. In this case, since the same electronic knowledge 4 is referred to a plurality of times, it is necessary to recognize the attributes as different attributes because logical consistency is required. Add. By going through such a process, the integrated electronic knowledge 4 shown in Fig. 22 can be obtained.

By aggregating, correcting, and adding the digitized knowledge 4 in accordance with the correction generation format 5 acquired in S700, the digitized knowledge 4 having better logical consistency is provided to the correction means 15 It is generated in (S710). The generated electronic knowledge 4 that is more logically consistent is referred to as resolved electronic knowledge.

In order to determine whether or not the resolved digitized knowledge generated in S710 is actually logically consistent, the verification generation format 6 (book In the embodiment, Check Pattern Component. Xs1) is obtained (S720), and the resolved electronic knowledge is verified in accordance with the verification generation mode 6. In other words, by applying the verification generation format 6 to the resolved electronic knowledge, logical inconsistencies, grammatical errors, etc. can be applied to the resolved electronic knowledge. A verification result is generated to determine whether the warning is included or an error (verification result is inappropriate) on the way (S730).

If the verification result in S730 includes a warning (S740), the verification means 16 notifies the contents of the warning (S750). If the verification result is inappropriate (for example, when an error has occurred) (S760), the content of the invalidity is notified (S770), and the process ends.

If no notification occurs from S740 to S770, it is determined that the digitized knowledge 4 can be used normally. Therefore, the program generation rule generation means 17 acquires the generation mode 7 for generation rule generation (Generate Generate Ru 1 e .xs 1 in the present embodiment) from the program generation method definition (S 7 8). 0), if the generation style 7 for the generation rule generation can be acquired (S790), a program generation rule is generated by applying the obtained generation style 7 for the generation rule generation to the resolved electronic knowledge. Yes (S800). Fig. 25 shows an example of the solved computerized knowledge, and the program generation rules generated as a result of applying the generation format for generation rule generation 7 to the computerized knowledge 4 in the program generation rule generation means 17 are shown. This is shown in Figure 26. In this example, generation style 7 for generation rule generation defines electronic knowledge for input 4, a generation style to be applied, and a name of a model of an executable program to be output.

If the program generation rule generation style cannot be obtained in S780, the program generation rule is obtained from the program generation method definition (S810).

From each generation unit in the program generation rules generated in S800 or S810, the template generation means 18 obtains the name of the electronic knowledge to be applied (S820), and obtains the obtained electronic knowledge. If the name (TestClass.xm1 in this embodiment) is the same as the digitized knowledge name of digitized knowledge 4 (S830), the resolved digitized knowledge is converted to the digitized knowledge name. It is assumed that the computerized knowledge 4 corresponds to (S840).

The digitized knowledge name acquired in S820 is the digitized knowledge name of digitized knowledge 4. If it is different from, the computerized knowledge 4 corresponding to the computerized knowledge name is acquired (S850).

The template generation means 18 generates a program corresponding to the output name of the program based on the computerized knowledge 4 and the program generation format 8 acquired in S840 or S850. That is, the program generation format 8 (Create Alignment Class, xs 1) is obtained from the generation unit of the program generation rule ^, and the obtained program generation format 8 is externally generated according to the contents of the electronic knowledge 4. When it is necessary to refer to the form (S870), a reference rule to an externally generated form according to the contents of the digitized knowledge 4 is added to the program generation form 8 (S880). When it is not necessary to refer to the externally generated form in S870, or after adding a reference rule to the externally generated form in S880, the name of the model of the program to be output from each generation unit of the program generation rules (In this embodiment, C Proated Program .java) is acquired (S890), and the digitized knowledge solved in the program generation form 8 (Test in this embodiment, Class.xml) The result of the application is output according to the output name of the program template (in the present embodiment, Argument C1 ass 1. java) (S900). Here, the template (ArgumentC1ass1.1java) of the program output by the template generating means 18 is a human-readable program to which the electronic knowledge 4 is applied.

The process from S820 to S900 is repeated until each generation unit of the program generation rules is processed (S910). That is, in the example of FIG. 26, ArgumentC1ass1.java and ArgumentC1ass2.java are generated.

After completing the processing of each generation unit of the program generation rule, the program configuration rule generation means 19 generates a configuration rule generation format 9 from the program generation method definition (in this embodiment, Generate Bui 1 d Xs1) is read (S920), and the program configuration rules that are the result of applying digitized knowledge 4 to generation style 9 Output according to the output name of the program (S930). Here, the program configuration rules generated by the program configuration rule generation means 19 are obtained by compiling the template of the program generated by the template generation means 18 in any order by the target program generation means 14 (from a human-readable program). (Machine-readable), which means a so-called makefile (makefi 1e).

The target program generation means 14 generates a machine-readable (ie, executable) final program based on the program model generated by the model generation means 18 and the program configuration rules generated by the program configuration rule generation means 19. Generate the target program. By performing the process flow from S100 to S930, an executable final purpose program in which physical characteristics and logical characteristics are reflected becomes possible.

In this specification, the computerized knowledge 4 is generated from the JAVA language or database based on the XML language, and the model of the JAVA language program is generated from the generated computerized knowledge 4 of the XML language. Although the case where it is generated as a machine-readable final purpose program has been described, the computerized knowledge 4 is generated in a programming language other than that, and the generated computerized knowledge 4 is also a computerized knowledge other than the XML language. The program may be generated in step 4, and a template of a program other than the JAVA language may be generated. Therefore, the computerized knowledge 4 of the XML language may be generated from the JAVA language, and the template of the program of the C language may be generated therefrom, or the computerized knowledge 4 of the C language may be generated from the Visua 1 Basic language, From there, a template for the JAVA language program may be generated.

Also, by providing the knowledge reuse system 1 with known communication means for transmitting and receiving data to and from other computer terminals via the network, a model of a program that can be executed via the network is provided. Can be generated.

Each means and database in the present invention are only logically distinguished in their functions, and may have the same physical or practical area. Also use data files instead of databases Needless to say, the description with the database includes the data file.

In carrying out the present invention, a storage medium storing a program of a program for realizing the functions of the present embodiment is supplied to a system, and a computer of the system reads and executes the program stored in the storage medium to execute the program. Of course, it will be realized.

In this case, the program itself read from the storage medium implements the functions of the above-described embodiments, and the storage medium storing the program naturally constitutes the present invention.

As a storage medium for supplying the program, for example, a magnetic disk, a hard disk, an optical disk, a magneto-optical disk, a magnetic tape, a nonvolatile memory card, and the like can be used.

When the computer executes the readout program, not only the functions of the above-described embodiments are realized, but also the operating system or the like running on the computer performs the actual processing based on the instructions of the program. It goes without saying that a case where some or all of the functions are performed and the functions of the above-described embodiments are realized by the processing is also included.

Further, after the program read from the storage medium is written into the non-volatile or volatile storage means of the function expansion unit inserted into the computer and the function expansion unit connected to the computer, the program Based on instructions, the function expansion board or the arithmetic processing unit provided in the function expansion unit may perform part or all of the actual processing, and the processing may realize the functions of the above-described embodiments. Is natural. Industrial applicability

According to the present invention, by separating a program generation method based on computerized knowledge from a development tool, by switching a program generation mode, a program template that can be automatically executed in an arbitrary generation mode Can be generated.

According to the present invention, in addition to the computerized knowledge, by recording the features on the user interface in a centralized manner, it is possible to generate a program for the user interface based on the computerized knowledge. In addition, by using a network such as the Internet for the program generation mechanism based on computerized knowledge, it is possible to share and reuse program-related knowledge in real time over the network. Becomes

Claims

The scope of the claims

1. A knowledge reuse system that automatically generates a model of an executable program on a computer.

, An interface formalizing means for reading a program and a Z or a database, and generating digitized knowledge having physical and logical characteristics of public information in the read program and the Z or the database;

The generated computerized knowledge, a program generation method definition specified by a developer for automatically generating an executable program template, and at least one or more predetermined generation methods for automatically generating a program. Program means for automatically generating a template of the executable program based on the formula

A knowledge reuse system characterized by having.

2. The interface formalizing means includes:

A source program interface formalizing means for reading the source program and generating digitized knowledge having physical and logical characteristics of the public information in the source program thus read;

The knowledge reuse system ( _{c) according} to claim 1, wherein

3. The interface formalizing means includes:

A target program interface formalizing means for reading the target program and generating digitized knowledge having physical and logical characteristics of the public information in the read target program;

Claims 1 characterized by having the knowledge reuse

4. The interface formalizing means includes:

Reads a database, digitized knowledge having physical and logical characteristics of tables and views in the read database Modeling information formalizing means to generate

The knowledge reuse system according to claim 1, wherein

5. The program means includes:

Based on the digitized knowledge generated by the interface formalizing means, the program generation method definition, and at least one or more predetermined generation modes for automatically generating the executable program template. A program generation means for automatically generating a human-readable program template

The knowledge reuse system according to claim 1, wherein

6. The program means includes:

An object program generating means for converting the template of the human-readable program automatically generated by the program generating means into machine-readable;

6. The knowledge reuse system according to claim 1 or claim 5, wherein

7. The program generating means includes:

Based on the correction generation format specified in the program generation method definition, digitization generated by the interface formalizing means is added and / or modified and / or aggregated, and the resolved digitization is performed. Correction means for generating knowledge;

Verifying means for verifying the solved digitized knowledge based on the verification generation format specified in the program generation method definition; and A program generation rule generation means for generating a program generation rule by applying the generation style for generation rule generation specified in

Template generating means for generating a template of a human-readable program based on the program generation mode specified in the program generation method definition and the generated program generation rule; A program configuration rule generating unit configured to generate a program configuration rule by applying the configuration rule generation generation style specified in the program generation method definition to the resolved computerized knowledge.

7. The knowledge reuse system according to claim 5 or claim 6, wherein

8. The knowledge reproduction method according to any one of claims 1 to 7, wherein the public information of the program and / or the database includes at least one of a variable, a class, a method, and a table view. Usage system.