JPS6288032A - Component selection method for program development - Google Patents

Abstract

(57) [Summary] This bulletin contains application data before electronic filing, so abstract data is not recorded.

Description

[Detailed Description of the Invention] [Field of Application of the Invention] The present invention relates to a component selection method for blockbrush development, and in particular, in program development, input/output data types are changed using a conversion dictionary for business processing terms. This relates to a component selection method in which a component (program fragment) is selected from a component storage file based on the determined data type.

[Background of the invention]

When developing software, it is effective to reuse previously used software.

In that case, a new program can be created by combining software components (ie, software fragments) registered in the database.

On the other hand, a method for developing programs by analyzing natural language, that is, an interactive natural language programming system, has been known (Transactions of the Institute of Electronics and Communication Engineers, 8).
4/3 Vol. J67-D No. 3 R Prototype of an Interactive Natural Language Programming System), this system collects data about the target input sentence,
Get those characteristics. The input sentence may be ambiguous,
Contains inconsistencies, so remove them by interacting with the user as necessary. Furthermore, in order to model the meaning of programs and sentences that the user is trying to create, a semantic model, a program model, and a code model are introduced. This system performs information acquisition processing that extracts information from Japanese sentences and compiles fragmented information.

Automatic programming and man-machine interface functions can be realized.

On the other hand, an automatic program synthesis method has been developed in which a program is stored as parts and then these parts are combined to create a new program. There is a problem that there is no uniformity in where they are classified, and automatic synthesis does not work efficiently. An example of developing a program by combining programs piecemeal is described in Jun Komoda, Yoshihiro Kobayashi, Yukio Ro, "Program Development Support Using Software Components: Paradigm" (Software Engineering 34-18). There is a method. In this method, 1
In order to find parts, we focus on the typical processing pattern of the application field to which we are applying componentization to avoid unnecessary increase in the number of parts, and in determining the form of parts, the software has This may be in the form of a subroutine or a source program library that is intended to be modified and used by the user, and it is necessary to select components appropriate for the purpose of use. However, this method has the problem that consistent classification becomes difficult when the number of software components increases. That is, most conventional classifications of program parts are based on function. In this classification method, even if the parts implement the same function, the program will often be completely different if the type of data that acts on them is different, and there is little flexibility to use other parts. Ta. Furthermore, it is often unclear to what function a new part is to be added, making it difficult to add it in a way that accurately brings out the performance.

[Purpose of the invention]

An object of the present invention is to improve such conventional problems, and when creating a program by combining one part, to be able to select an appropriate part from a parts accumulation file, and to be able to add new program parts. The object of the present invention is to provide a component selection method for easy program development.

[Summary of the invention]

In order to achieve the above object, the program rj according to the present invention
In the component selection method for HM, in order to develop a new program by combining program components that indicate computer processing procedures, the required specifications of the developed program are semantically analyzed by reasoning using rules.

In the method of creating a data flow and selecting parts corresponding to each node of the data flow from an existing parts accumulation database, the computer processing objects that are cursed by each business are described in business processing terms and systematized. It also has a conversion dictionary that describes input/output data types in computer processing as characteristic items of each object, and by referring to the conversion dictionary, input/output data specified by business terms in the above requirement specifications can be converted. On the other hand, the present invention is characterized by assigning an input/output data type to each node of the data flow, searching the parts accumulation database according to the input/output data type, and determining the parts to be combined.

[Embodiments of the invention]

Hereinafter, embodiments of the present invention will be described in detail with reference to the drawings.

FIG. 1 is a block diagram of a software component search system showing one embodiment of the present invention.

In FIG. 1, 1 is a video data terminal equipped with a display and a keyboard.

2 is a computer processing device, 3 is an inference rule accumulation file, 4 is
is a conversion dictionary file, 5 is an existing parts accumulation file, 6 is a parts selection processing unit, 7 is a requirements specification analysis unit, 8 is a data flow creation unit, 9 is a conversion dictionary search unit, 10 is a parts database search unit, 11 is a rule This is the inference part by.

In this example, if the input/output data described in the requirements specifications is described in business terms that indicate what the data is without specifying a strict data type, computer processing can be performed by referring to a conversion dictionary. You can determine the appropriate data type and select the parts accordingly, so you can
When creating requirement specifications, there is no need to consider the processing content and specify data types.

FIG. 2 is an operation flowchart showing the control procedure of FIG. 1. First, read the requirement specifications written in natural language, analyze them by referring to the rule accumulation file (step 1ot), and create a data flow with computer operations as nodes and input/output data to the computer operations as arcs. (Step 102).

Each node of the data flow is expressed as the following structure.

(Node name (input/output data type) (data flow) (function) ......) Here, since the input/output data of the requirement specification was written in business terms, the input/output data of each node The output data type is only a data name, and the data type is not described.

Next, a conversion dictionary is used to assign data types to the input and output data of each node. The conversion dictionary is a structure as shown below.

(Data type (computer processing name (input (data type)) (output (data type))) (...)...)...) (...
・・・・・・・・・) For each data at each node, the data type is determined based on the type of data specified in business terms, the name of the computer processing performed at that node, and whether the data is input data or output data. (Steps 103 and 104). The determined data type is written into the data flow (step 105), and if it cannot be determined from the conversion dictionary, human interaction is performed (step 1).
06).

For the nodes for which all data types have been determined, appropriate parts are selected by inference from the parts accumulation file organized by data type (step 107) and written in the parts correspondence diagram (step 108). Here too, human interaction is performed only when there is no corresponding part (step 109).

Similarly, for all nodes, determine the input/output type and determine the parts to be used (steps 110 and 111).
.

Figure 3 shows an example of requirements specifications written in natural language, Figure 4 is a data flowchart created from the requirements specifications in Figure 3, and Figure 5 is part of a systemized parts accumulation file. FIG.

Next, with reference to FIGS. 3, 4, and 5, a procedure for creating a data flow from a natural language requirement specification and selecting corresponding parts will be described for a simple example. In Figure 3, the requirements specifications of the program that we are about to develop are written in natural language.

Input/output data is specified in business terms.

When a data flow chart is created from the required specifications shown in FIG. 3, it becomes as shown in FIG. 4. The input/output data type of each node structure is still blank.

FIG. 5 shows some of the systemized parts.

First, read the requirement specifications in Figure 3, perform inference based on rules using case grammar analysis, and create the data flow chart in Figure 4.Next, determine the data type for each node in Figure 4. and select the part. Here, the contents of the conversion dictionary are as follows.

(Unit price (input (input (external 10 type)) (output (external 1 type)
0′d! A type))) (Ia collection (input (external IO base type)) (output (character string type))...) Since even a 1 yen error is not allowed for the unit price, external IO is used for input and calculation. Since it is fixed to be a base type and a string type when outputting, I decided by inference to convert it to a string type in the &I collection and created it. Even if there are two quantities and amounts, they have similar structures.

First, in FIG. 4, 4-1 is A as input data.
, B. Since A is the unit price and is input data for input processing, it is determined that it is an external decimal type. B is also a quantity and is input data for input processing, so
It is an external lO base type.

It can be seen that the output data A and B of 4-1 are also of external decimal type. The structure for node 4-1 is now determined as follows.

(Input data type (A: external decimal type) (B: external decimal type)) (Output data type (A: external decimal type) (B: external io decimal type)) (Data flow (... ))...) Next, select the corresponding parts for this 4-1.

The input data of 4-1 is external IO base type, so the fifth
In the figure, lower parts 5-1 are used.

In addition, since 4-1 is input processing, 5-2
It becomes the lower part of . Then, search for one with the function of 3-1 from among the several parts that correspond to 5-2 (i.e., A and B are input from the keyboard).
, As a result, if 5-4 is selected, node 4-1
This means that the component Road-1 is used for the component Road-1. A component is a structure with the following shape.

(Part name (attribute) (Input/output data type) (Function) (Source code)...) However, for source codes that are common to multiple parts, It is written in the structure and shall be inherited.

Next, for 4-2, input data A,
It can be seen that B is an external decimal type, and the output data C is also an output of an amount calculation process, so it is an external decimal type.

Then, at 5-1 in FIG. 5, it is determined by inference that the lower component 5-5 of the calculation process 5-3 is to be used.

Similarly, for 4-3, input data A.

B and C are external decimal type, output data A, B, and C are character type, and the corresponding parts are lower-order ones of 5-1.

Regarding 4-4 as well, it can be seen that input data A, B, and C1 and output data A, B, and C are all of one character string type, and the corresponding parts are lower-order ones of 5-6.

In this way, the parts to be used are determined for each node of the data flow.

In this embodiment, since the task is to create a slip, a sales conversion dictionary and parts database are used.

By preparing other dictionaries and parts, similar processing can be performed for programs related to other occupations, such as numerical calculation programs. In this way, in this example, when describing requirements specifications in natural language, input/output data can only be specified in business terms, and appropriate data types can be determined by inference for internal computer processing. You can make assignments and select parts accordingly.

FIG. 6 is a block diagram of a program development system showing another embodiment of the present invention. In FIG. 6, 1 is a terminal (keyboard/display), 2 is a processing device for selecting and combining program parts, 13 is a database for classifying and storing program parts, and 14 is a developed source program.

Normally, program parts are classified based on one function, but this means that even if the parts implement the same function, if the type of data that exerts one effect is different, the program will be completely different. In many cases, there was little flexibility in reusing other parts. Furthermore, it is often unclear which function a newly added component will perform, making it difficult to add it in a way that maximizes performance. Therefore, in this embodiment, programs are classified according to the type of data that their parts act on so that it is clear where they are classified. Furthermore, a hierarchy is provided according to the derivation relationship belonging to the data type so that parts belonging to another related data type can be easily used. As a result, the effects that can be exerted on each data type can be restricted, making it possible to develop highly modular programs.

FIG. 7 is a diagram of the hierarchical structure of data types showing the fifth embodiment of the present invention, and FIG. 8 is a diagram showing the Tj product of program parts and the state of references to higher-level data types.

A program component that implements one small function has data on which that function acts, and that data has some data type as an attribute. For example, in the case of a component that "writes a value X to be displayed on a display," the data to be affected is X, and its data type is, for example, a character type. Since the target data type for such an action is clearly determined for each program component, components that have this in common are collected into one group. However, data types given names by the user are classified into the corresponding data types in machine representation.

These data types are layered into nine layers according to the rules described below. (a) The top layer is "integer type", "real number type",
There are four types: "character type" and "pool type". (h) Array types, set types, and record types shall be hierarchically placed directly under the types of their constituent elements. (c) A subrange type is hierarchically placed directly under the type that limited one part. (d) Scalar types are hierarchically placed directly under integer subrange types. (e) Other user-defined types are hierarchically placed directly below the types created using the rules (=) to (d) that correspond to those types.

Figure 7 shows an example of a hierarchy created according to the above rules, in which some parts with similar functions are modified for those belonging to data types higher in the hierarchy, and operations on that data type are performed. It is possible to configure parts for This makes it easy to create a program component that understands one derived data type.

Next, the situation of program development executed by combining program parts classified according to this embodiment will be explained in detail. The developer outlines the program he/she wants to create.
Write it as a chain of simple sentences. Each simple statement either represents some operation on some data or defines the order of execution of a program. From this outline, the system extracts a simple sentence for an operation on certain data,
Extract those with matching operation contents from the program parts group classified into the corresponding data type. The extracted program parts do not have variable names filled in as they are, and cannot be combined with other parts as they are.
Perform unification based on the program outline. After that,
A complete program is created by combining the selected program parts according to a simple sentence that defines the execution order.

Next, with reference to FIG. 8, the accumulation form of program parts and the state of addition of new parts will be described. Is the actual program part text 44 independent of the part that defines the data type hierarchy? It is multiplied by S. Each data type has
It describes identifiers that refer to parts belonging to that type, methods for unifying variable names, and methods for transforming parts to match the type.

For example, a program component with a function of ``total J'' in the data type ``integer array'' 42 can be applied as is to a structure containing an integer array.

In such cases, so that you do not have to register twice,
It is equipped with a function that uses the data type hierarchy to indirectly refer to program parts that belong to higher-level data types. This means that even if the desired program component is not in the classification of the applicable data type, if there is a component with the same function that is classified as a higher data type, it will be inherited and if necessary, it can be changed to that type. The combined transformation is performed and output.

For example, in FIG. 8, there is no program component that operates on the [lI number sequence character string structure] 43 and converts the integers in the array into character strings.

However, it is possible to request a reference to the "integer array" 42 in the upper layer. When the "integer array" 42 receives this application, it applies for reference to the higher-level "integer type" 41, and the program component with the function of "converting an integer to a string" belonging to the "integer type J41" 44 is r
′! The receiver is passed to ``Ii number array'' 42, and ``!1 number array'' 4
2 transforms this so that it repeats, and makes it suitable for the array type. Furthermore, it is passed to the "integer array/character string structure" 43, and the structure 43 outputs it as is. In this way, the structure 43
It is possible to realize a conversion function 44 that can be used in various ways.

When adding a new program component to a certain type, conversely, use a program component that belongs to a higher-level type, and if necessary, describe and register the method for transforming it. .

In this example, unlike classification that relies on human experience,
Identical parts will be classified in the same place even if all people do it. Therefore, appropriate parts can be selected efficiently and new parts can be easily stored, thereby increasing the efficiency of program development.

In this way, when developing a new program by assembling existing software components, in the first embodiment,
When selecting parts that correspond to a data flow, by using a conversion dictionary created according to the business content, input/output data written in business terminology in the requirement specifications can be An appropriate data type is assigned to each node in the data flow, and the systemized parts accumulation file can be searched using the input/output data type to select the part corresponding to the data flow node.

As a result, when creating requirement specifications, there is no need to designate data types by considering the details of internal computer processing, and it is only necessary to describe the type of data in business terms.

In addition, in the second embodiment, when classifying program parts, the parts are classified according to the type of data that they act on, and data type derivatives are created so that parts belonging to another related data type can be easily reused. By creating a hierarchy according to relationships, we can limit the effects that can be exerted on each data type.

In addition, when adding new parts, you can use parts that belong to higher-level types, and if necessary, describe and register how to transform them, so that no matter who does it, the same parts will be classified in the same place. This makes it easier to accumulate parts and improves development efficiency.

〔Effect of the invention〕

As explained above, according to the present invention, by using a conversion dictionary created according to the business content, it is only necessary to describe the type of data in business terminology, so the program development procedure can be streamlined. In addition, it is possible to efficiently select appropriate parts, and it is easy to add new program parts. By doing so, program development efficiency will improve.

[Brief explanation of drawings]

Fig. 1 is a functional block diagram of a program development system showing a first embodiment of the present invention, Fig. 2 is a flowchart showing the control procedure of Fig. 1, and Fig. 3 is a requirement specification written in natural language according to the present invention. An example diagram, Figure 4 is a data brooch yard created from the required specifications in Figure 3, Figure 5 is a diagram showing part of a systemized parts accumulation file, and Figure 6 is a diagram showing the second part of the present invention. FIG. 7 is a block diagram of a program development system showing an example. FIG. 7 is a diagram configuring a data type hierarchy based on this example. FIG. 8 is a diagram showing the accumulation of program parts and reference to higher-level data types. be. 1: Terminal (video data terminal), 2: Processing device (
CPU), 3: Inference rule accumulation file, 4: Conversion dictionary file, 5: Existing parts accumulation file, 6: Component selection processing section, 7: Requirement specification analysis section, data flow creation section, 9
: Conversion dictionary search unit, 10: Parts database search unit, l
1: Inference section based on rules, 13 Database for classifying and storing Niprogram parts, 14: Developed source program.

Claims (3)

[Claims] (1) In order to develop a new program by combining program parts that indicate the processing steps of a computer, the requirements specifications of the development program are semantically analyzed by reasoning using rules, a data flow is created, and existing parts are In the method of selecting parts corresponding to each node of the data flow from the accumulated database, the computer processing objects that appear in each task are described in business processing terms and systematized, and the computer processing objects are described as characteristic items of each object. It has a conversion dictionary that describes the input/output data types in the above data flow, and by referring to the conversion dictionary, input/output data specified by the business terminology in the above requirement specifications can be input/output data for each node of the above data flow. A parts selection method for program development characterized by assigning an output data type, searching a parts accumulation database according to the input/output data type, and determining parts to be combined. (2) The above parts accumulation database is classified based on the type of data that the program parts act on, and each set of parts is hierarchically organized based on the derivation relationship of the data type, and parts in higher layers are also used as necessary. A component selection method for program development according to claim 1, characterized in that the component selection method is adapted to perform program development. (3) In the above-mentioned parts accumulation database, when a new part is added, a part belonging to a type in a higher hierarchy is used, and when necessary, a description of how to transform the part is registered. Part selection method for program development described in scope 1.