JP2001043079A - Device for supporting software development, device and method for generating software part, and recording medium - Google Patents

Abstract

PROBLEM TO BE SOLVED: To make efficiently executable software development by forming each of soft ware parts belonging to each of categories while dividing the software parts into common function parts being common to the software parts and non-common function parts that are peculiar to individual parts. SOLUTION: A common function storing part 1 stores a common function module 2 being common to software parts belonging to a 1st category in which the input of data is handled, a common function module 3 being common to software parts belonging to a 2nd category in which the input-output of the data is handled and a common function module 4 being common to software parts belonging to a 3rd category in which the output of the data is handled. A non-common function generating part 5 generates non-common function modules 6a, 6b,... which are characteristic to each software part among functions constituting the software part. Then, a part generating part 7 generates a software part by selectively combining the modules 6a, 6b, ... and the modules 2 to 4 belonging to any of stored categories.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a software development support device, a software component generation device and a method thereof,
Regarding recording media, in particular, GUI (Graphical User Inter
The present invention is suitable for use in an apparatus in which software development is performed by pasting a base) software component on a screen and connecting the pasted components together.

[0002]

2. Description of the Related Art In recent years, computer systems have been used in a wide variety of applications throughout the world, and the range of use has been expanding. The performance of the CPU used in this computer system has been dramatically improved, and a high-precision display such as a bit map display has also become widespread.

[0003] Against this background, software development has started from a character-based user interface.
Emphasis has been placed on building user interfaces that are easier to use. For this reason, various tools have been proposed that enable creation of target software (programs) by combining various software components using a GUI.

[0004] Here, the software component generally refers to a program in functional units prepared for the purpose of reuse. That is, by creating a function commonly used in many programs as a software component, it is not necessary to re-create a program having the same function many times. By reusing the software components, it is possible to improve the productivity of the software.

[0005] When developing an application using this kind of tool, first, a requirement definition of an application to be created is defined, and analysis and design in an object-oriented manner are performed to satisfy the requirement. Then, various software components are created based on the results of the analysis and design, and the created software components are used in any combination to complete the application. At this time, if any of the already created software components can be used, it can be used.

[0006]

However, in the above-mentioned prior art, the efficiency of application development can be improved by reusing already created software components.
All the program code for realizing the functions to be provided to the component had to be described from the beginning. Therefore, there has been a problem in that creation of software components requires a great deal of labor.

Further, when creating software components, it is necessary to understand an execution environment (framework) for making various software components actually function, and to code a program so as to conform to the framework mechanism. there were. Therefore, it was difficult for developers who did not know the framework mechanism to create software components. Therefore, if the software component that the user wants to use is not registered, the developer who understands the framework has to be asked to create the desired software component, which is a factor that lowers the development efficiency. Was.

Furthermore, conventional software components have different functional units for each component, and many software components have a plurality of functions. In this case, if software components having such a large function unit can be used as they are, productivity of software development is considerably improved, but there are not a few cases where it is desired to change and use some of the functions. However, in this case, since the software component cannot be used as it is, it is necessary to create a software component that meets the requirements from the beginning, which increases the burden on the developer.

The present invention has been made to solve such a problem, and an object of the present invention is to reduce the burden on a software developer and to make software development more efficient. I do.

[0010]

A software development support device according to the present invention is a software development support device configured to develop desired software by combining software components. , A second software component that handles data input / output, and a third software component that handles data output. The software components belonging to the above three categories are divided into three categories. It is characterized in that each component is divided into a common function portion common to each software component and a non-common function portion unique to each software component.

A software component generation device according to the present invention is a software component generation device for generating a software component of a predetermined function unit, wherein a common function common to each software component belonging to a first category for handling data input is provided. A module of a common function part common to each software component belonging to the second category handling data input / output and a common function part common to each software component belonging to the third category handling data output is stored. Common function storage means, a non-common function generation means for generating a module of a non-common function part unique to each software component, and a module for the non-common function part generated by the non-common function generation means. The common function part belonging to any of the categories stored in the function storage means Characterized in that a component generating means for generating a software component by combining the module selectively.

A software component generation method according to the present invention is a software component generation method for generating a software component in a predetermined function unit, wherein a common function common to each software component belonging to a first category for handling data input is provided. A module of a common function part common to each software component belonging to the second category handling data input / output and a common function part common to each software component belonging to the third category handling data output is provided in advance. Create and save, generate a module of the non-common function part unique to each software component, and the generated module of the non-common function part,
A desired software component is generated by selectively combining modules of the common function part belonging to any of the stored categories.

Further, the computer-readable recording medium according to the present invention provides a common function portion common to each software component belonging to a first category for handling data input, and a common function portion for each component belonging to a second category handling data input / output. A common function storage unit for storing a common function part common to the software components and a module of the common function part common to each software component belonging to the third category for handling data output; A non-common function generating means for generating a module of a common function part, and a module belonging to any one of the modules of the non-common function part generated by the non-common function generating means and the common function storage means By selectively combining modules with common function parts, software components can be And characterized by recording a program for causing a computer to function as a component generating means for forming.

Since the present invention comprises the above technical means, when it is desired to create a desired software component, it is possible to use a pre-stored common function portion and create only a non-common function portion unique to the software component. Get better. Further, when a desired application is generated by combining software components, it is possible to effectively use software components generated for each functional unit of data input, data input / output, and data output.

[0015]

DESCRIPTION OF THE PREFERRED EMBODIMENTS One embodiment of the present invention will be described below with reference to the drawings. FIG. 1 is a block diagram illustrating a main functional configuration example of a software development support device according to the present embodiment. The software development support device shown in FIG. 1 includes the configuration of the software component generation device according to the present embodiment.

In FIG. 1, reference numeral 1 denotes a common function storage unit, which stores modules (programs) for realizing functions common to a plurality of software components for each of the following three categories.

The first category is a category to which software components handling data input belong. Input software components belonging to this category include, for example, reading data from a file, and URL (Uniform Resource).
Locator) is a software component that is programmed specifically for functions that generate data on an application, such as capturing data from a network or capturing data from a database.

The second category is a category to which software components handling data input / output belong. Input / output software components belonging to this category include, for example, converting and inputting data input from outside,
It is a software component that is programmed specifically for the function of processing and outputting input data. The input / output software component may be programmed with a function (for example, a delay or the like) of outputting the input data without conversion.

The third category is a category to which software components handling data output belong. Output software components belonging to this category include, for example, storing data in a file, displaying on a display device,
It is a software component programmed specifically for the function of discharging data, such as printing by a printing device.

As described above, in the present embodiment, various software components are defined as an input software component for handling data input, an input / output software component for handling data input / output, and an output software component for handling data output. Parts are managed in three categories. Further, each of the software components belonging to the above three categories is divided into a functional portion common to each software component and a functional portion unique to each software component, and only the program of the common functional portion is shared for each category. The function is stored in the function storage unit 1.

That is, the common function storage unit 1 includes a common function module 2 common to each software component belonging to the first category handling data input and a software component belonging to the second category handling data input / output. And a common function module 4 common to each software component belonging to the third category that handles data output.

Reference numeral 5 denotes a non-common function generation unit, which is a non-common function module 6a, 6b, 6c,
... is generated. Also, reference numeral 7 denotes a component generation unit which divides the non-common function modules 6a, 6b, 6c,... Generated by the non-common function generation unit 5 into any of the categories stored in the common function storage unit 1. Software components are generated by selectively combining the common function modules 2 to 4 to which they belong. Which category the common function modules 2 to 4 to use are selected using the function selection unit 8.

Reference numeral 9 denotes a component registration unit.
Is registered in the component storage unit 10. Reference numeral 11 denotes a component selection unit, and the component storage unit 1
In order to select a desired software component that can be used for an application to be created, from among several software components stored in “0”. An application generation unit 12 generates an application using a software component selected by the user.

When generating an application, the user first pastes some GUIs of the software components selected using the component selection unit 11 on a display screen, and connects the pasted software components together by wiring. , Make an association. Then, when the arrangement and the wiring of the software components are completed, the execution of the software generating function is instructed, and the application generating unit 12 generates the program code according to the arrangement and the wiring state. In addition, the application generation unit 12 may automatically perform the processing up to compiling.

Next, common function modules 2 to 4 having functions common to each software component, and non-common function modules 6a and 6 having functions unique to each software component.
The detailed configuration of b, 6c,... will be described based on FIG.

As shown in FIG. 2, the input software component is configured by combining a data input common function module 2 and a non-common function module 6a. The input / output software component is configured by combining the data input / output common function module 3 and the non-common function module 6b. The output software component is configured by combining the data output common function module 4 and the non-common function module 6c.

One software component is composed of a group of objects (modules) related to three classes: a frame class, a logic object generation class, and a logic implementation class. Of these, the frame class and the logic object generation class constitute common function modules 2 to 4, and the logic implementation class constitutes non-common function modules 6a to 6c.

In the example of FIG. 2, the class configuration of the common function module 2 and the non-common function module 6a mounted for data input is shown as a representative. Hereinafter, the common function modules 2 to 4 of the software components are referred to as “frame units”, and the non-common function modules 6 a to 6 c are referred to as “logic units”.

The above-mentioned frame class corresponds to the first module of the present invention, and includes a description relating to a definition unit 21 for generating a logic object, a setting unit 22 for referring to a logic object, and a unit input / output processing unit 23. Including. Here, the definition part 2 of the generation of the logic object
1 describes the name of a function for expanding the logic 25 belonging to the logic implementation class into the internal memory. In addition, the setting unit 22 of the reference destination of the logic object includes:
The return destination of the result of the actual processing performed by the logic 25 is described.

The unit input / output processing unit 23 describes processing relating to data input / output performed with other software components. For example, in the frame class related to the common function module 2 for data input, a process of outputting the processing result of the logic 25 returned to the return destination to another software component is described. In the frame class related to the data input / output common function module 3, processing for inputting data from another software component and outputting the processing result of the logic 25 returned to the return destination to another software component are output. The processing is described.

The above logic object generation class is:
The description about the generation unit 24 of the logic object is included. In the logic object generation unit 24, processing for expanding the program of the specified logic 25 in the internal memory of the computer is described. This logic object generation class corresponds to the second module of the present invention.

The logic implementation class includes a description related to the logic 25. The logic 25 describes a specific process performed by the software component. For example, if you want to create an input software component, the logic of data input is described.If you want to create an input / output software component, you describe the logic of data conversion, etc., and you want to create an output software component. In
The logic of data output is described.

The operation of the software component composed of the three classes as described above is as follows. For example, in the case of an input software component, first, in accordance with the program of the function specified by the logic object generation definition unit 21, the logic object generation unit 2
4 is loaded and expanded on the internal memory. The logic 25 expanded in the internal memory is
Execute the contents of the program written there.

At this time, if a program for reading data from a file is written in the logic 25, a process of reading data from a designated file is performed. In addition, if a program for taking in data from a network, database, GUI, etc. is written,
A process for capturing data is performed according to the program.
The data input in this way is returned to the return destination set by the setting unit 22 for the reference destination of the logic object. Then, the unit input / output processing unit 23 outputs the data returned to the return destination to the outside.

FIGS. 3 to 6 are diagrams showing examples of programs corresponding to the frame class, the logic object generation class, and the logic implementation class, respectively. This program is an example described using the Java language which is an object-oriented programming language developed by Sun Microsystems. In these programs, lines between / * and * / and with // are comments. 3 to 6 show examples of programs relating to software components for data input (source type).

FIG. 3 shows a program example (Source.java) of the frame class. In the program of FIG. 3, the 18th to 21st lines and the 26th to 37th lines are
This is a part corresponding to the setting part 22 of the reference destination of the logic object. In this case, the logic implementation class sets itself as the return destination of the processing result in the logic 25. The 23rd line is a part corresponding to the definition unit 21 for generating a logic object, and here defines the name of a function for expanding the logic 25 of the logic implementation class on the internal memory. The 39th line and subsequent lines correspond to the unit input / output processing unit 23, in which a function group for realizing the basic function of the input software component is described.

FIG. 4 shows a program example (XSource.java) of the above logic object generation class. In the program of FIG. 4, the contents of the function for expanding the logic 25 on the internal memory, which are defined only in the frame class, are implemented in the 16th to 20th lines.

FIG. 5 shows a program example (XGenerator.java) of a logic implementation class. In the program of FIG. 5, the following FIG.
In addition to the functions defined in the Soucable class shown in (1), a function for processing the logic 25 is implemented from the 37th line onward.

FIG. 6 shows an example of a class program (Soucab) that defines the names of functions that the logic implementation class should have.
le.java). The logic implementation class uses this Soucab
You must implement the functions defined in the le class.

FIG. 7 is a class configuration diagram showing the relationship between the classes shown in FIGS. In FIG. 7, the relationship between the frame class (Source) 31 and the logic object generation class (XSource) 32 is a class based on the frame class (Source) 31, and the logic object generation class (XSource) 32 defines Indicates that this is an extended class.

A logic object generation class (XSource) 32 and a logic implementation class (XGenerator)
The relationship with 33 indicates that the logic object generation class (XSource) 32 generates the logic implementation class (XGenerator) 33.

The relationship between the frame class (Source) 31 and the logic implementation class (XGenerator) 33 is as follows:
This indicates that the frame class (Source) 31 is the class to be called, and the logic implementation class (XGenerator) 33 is the class to be called. At the time of this call, a class (Soucable) 34 defining a function used for the call is used.

In the software development support apparatus according to the present embodiment configured as described above, a frame portion (frame class and logic object generation class in FIG. 2) which can be commonly used as functions of various software components is created in advance. When it is desired to create a desired software component by storing it in the common function storage unit 1, only a logic unit (logic implementation class in FIG. 2) having a function specific to the software component needs to be created.

Although it is necessary to slightly modify the frame portion, it is only necessary to change the description of the name of the logic to be developed on the memory. That is, in the XSource program shown in FIG. 4, the description of XGenerator () representing the name of the logic to be used only needs to be changed according to the name of the logic to be used. There is no need to change the description of the input / output processing describing the substantial function of the frame part.

Therefore, the developer of the software component only needs to code the program of the logic part desired by himself, and the range of the program to be described is smaller than in the conventional case where the entire software component is coded from the beginning. Can be reduced. Therefore,
The burden on the developer can be greatly reduced, and the work efficiency of software component development can be dramatically improved.

Further, since the frame portion is hardly required to be modified, the developer has a mechanism of the frame portion, a mechanism of an execution environment (framework) for making the generated software components actually function, and the like. It is not necessary to understand exactly. Therefore, even developers who do not know these mechanisms can easily create software components as long as they have the ability to create a logic part.

Further, in the present embodiment, since the above-mentioned frame portion is further divided into three categories of input, input / output, and output, there is a merit that the created software component can be easily reused. Have. That is, conventionally, one software component often has a plurality of functions such as data input, data output, and data conversion. However, for example, when you want to change only the data input function without changing the data conversion function,
If there is no other convenient software component that differs only in the function of data input, it is necessary to create a software component that meets such requirements from the beginning.

On the other hand, according to the present embodiment, since the frame part of the software component is divided into the minimum function units, the data conversion function is not changed and only the data input function is provided as in the above-described example. Even if you want to change
Only the software components for data conversion need to be replaced, and the software components for data input can be reused as they are. At this time, even if there is no appropriate software component for data conversion, it is very simple to create the software component itself as described above. Therefore, the work efficiency of software component development can be greatly improved.

Further, by dividing the software component into three minimum function units for input, input / output, and output, it is possible to clarify the role unique to each. That is, for example, a software component for input can be provided with a mechanism for receiving the timing of starting data input from the outside. For example, when the user presses a button for starting the GUI, data reading can be started with the action start event as a trigger.

For example, a mechanism for forcibly terminating the data conversion process can be provided for input / output software components. For example, when some trouble occurs during the data conversion process and the process runs away, the event can be used as a trigger to stop the data conversion process. Further, in the input / output software component, the data conversion process can be started by inputting some data from outside as a trigger.

For example, a software component for output can be provided with a mechanism for starting data output processing triggered by input of some data from outside. For example, an event input from an input / output software component may be used as a trigger to perform a process such as outputting a result of data conversion processing in the input / output software component to a file or a chart.

By pasting the software components generated for the respective functions for input, input / output, and output on the screen as described above, and joining the pasted software components together, You will be able to create application software. FIG. 8 is a diagram illustrating an example of creating an application that reads data from a file using a plurality of software components, performs a neuro operation, and outputs the operation result to a file and a chart.

In FIG. 8, reference numeral 41 denotes a component for generating a start signal, for example, a start button of a GUI or the like. Reference numeral 42 denotes a file reading component, which is configured by the input software component of the present embodiment. Reference numeral 43 denotes a neuro operation component, which is configured by the input / output software component of the present embodiment. Reference numeral 44 denotes a distribution component having a function of distributing one input data to two.

Reference numeral 45 denotes a file writing component;
Are calculation result display components, both of which are constituted by output software components of the present embodiment. Note that the start-up component 41 and the distribution component 44 are also prepared as standard in a conventional software development support tool.
In the present embodiment, this can be used as it is.

As shown in FIG. 8, the plurality of software components 41 to 46 are pasted at appropriate positions on the screen, and the pasted software components are connected to each other by lines. Application software according to the function and wiring method is automatically generated.

At this time, the execution environment (framework) of the development support apparatus automatically determines the relationship between the input source and output destination of data for each software component based on the drawn wiring and the like. Automatically generate that part of the program. This function utilizes a function of a conventional software development support tool.

The software development support apparatus according to the present embodiment described above comprises a CPU or MPU of a computer, a RAM, a ROM, etc., and operates a program stored in the RAM or the ROM. Can be realized by Therefore, the present invention can be realized by recording a program that causes a computer to perform the above function on a recording medium such as a CD-ROM, and reading the program into the computer. As a recording medium for recording the above program, a CD
-In addition to the ROM, a floppy disk, a hard disk, a magnetic tape, a magneto-optical disk, a nonvolatile memory card, and the like can be used.

Further, the functions of the above-described embodiment are realized not only by the computer executing the supplied program, but also by the OS (Operating System) or other application software running on the computer. When the functions of the above-described embodiment are realized in cooperation with the computer, or when all or a part of the processing of the supplied program is performed by a function expansion board or a function expansion unit of a computer, the functions of the above-described embodiment are realized. Such a program is also included in the embodiment of the present invention.

The above-described embodiments are merely examples of implementation of the present invention, and the technical scope of the present invention should not be interpreted in a limited manner. It must not be. That is, the present invention can be embodied in various forms without departing from the spirit or main features thereof.

[0060]

According to the present invention, as described above, a software component includes a common function portion common to each software component,
Since the software components are divided into non-common function parts unique to each software component, the above-mentioned common function parts are created and stored in advance, so that if you want to create a desired software component, Only the non-common functions need to be created, and the work efficiency of software development can be greatly improved. In addition, since there is almost no need to modify the common function part, developers do not need to understand the mechanism itself exactly, and even developers who do not know the mechanism can easily create software parts. . Further, in the present invention, the software component is divided into three minimum functional units: a software component for handling data input, a software component for handling data input / output, and a software component for handling data output. Therefore, the created software components can be easily reused. Therefore, according to the present invention, the burden on the software developer is greatly reduced, and software development can be performed more efficiently.

[Brief description of the drawings]

FIG. 1 is a functional block diagram illustrating a configuration example of a software development support device according to an embodiment of the present invention.

FIG. 2 is a diagram illustrating a detailed configuration of a frame unit having a function common to each software component and a logic unit having a function unique to each software component.

FIG. 3 is a diagram illustrating an example of a frame class program.

FIG. 4 is a diagram illustrating an example of a program of a logic object generation class.

FIG. 5 is a diagram illustrating an example of a program of a logic implementation class.

FIG. 6 is a diagram illustrating an example of a class program defining names of functions to be possessed by a logic implementation class;

FIG. 7 is a class configuration diagram showing a relationship between the classes shown in FIGS. 3 to 6;

FIG. 8 is a diagram illustrating an example of a screen for generating an application using a plurality of software components.

[Explanation of symbols]

DESCRIPTION OF SYMBOLS 1 Common function storage part 2 Common function module of input software parts 3 Common function module of input / output software parts 4 Common function module of output software parts 5 Non-common function generation part 6a Non-common function module of input software parts 6b Non-common function module of input / output software component 6c Non-common function module of software component for output 7 Component generation unit 8 Function selection unit 9 Component registration unit 10 Component storage unit 11 Component selection unit 12 Application generation unit 21 Logic object generation Definition unit 22 Logic object reference destination setting unit 23 Unit input / output processing unit 24 Logic object generation unit 25 Logic

Claims (6)

[Claims] 1. A software development support apparatus configured to develop desired software by combining software components, wherein said software component is connected to a first software component that handles data input and data input / output. The software component is divided into three categories: a second software component to be handled and a third software component to handle data output. Each of the software components belonging to the three categories is divided into a common function portion common to each software component, A software development support device characterized in that it is divided into non-common functional parts unique to each software component. 2. The common function part of the software component includes: a first module including a definition unit for expanding a module of the non-common function part used with the common function part on a memory; The software development support device according to claim 1, further comprising: a second module that expands a module of the non-common function part on a memory. 3. The first module executes, in addition to the definition unit, a setting unit for setting a reference destination of the module of the non-common function part, and at least one of data input and output functions. The software development support device according to claim 2, further comprising an input / output unit that performs the operation. 4. A software component generation device for generating software components of a predetermined function unit, wherein the software component generation device generates a common function portion common to each software component belonging to a first category that handles data input and handles input / output of data. Common function storage means for storing a module of a common function part common to each software component belonging to the second category and a module of a common function part common to each software component belonging to the third category which handles data output; A non-common function generating means for generating a module of a non-common function part unique to the software component; a module of the non-common function part generated by the non-common function generating means and any of the modules stored in the common function storing means By selectively combining the modules of the common function part belonging to And a component generating means for generating software components. 5. A software component generation method for generating a software component of a predetermined function unit, comprising: a common function portion common to each software component belonging to a first category for handling data input; A module of a common function part common to each software component belonging to the second category and a module of a common function part common to each software component belonging to the third category that handles data output are created and stored in advance, respectively. Module of the non-common function part unique to the software component of the above, and selectively generates the generated module of the non-common function part and the module of the common function part belonging to any of the stored categories. A desired software component is generated by combining them. Software component generation method. 6. A common function portion common to each software component belonging to a first category handling data input, a common function portion common to each software component belonging to a second category handling data input / output, and data Common function storage means for storing a module of a common function part common to each software component belonging to the third category which handles the output of the software, and a non-common function for generating a module of a non-common function part unique to each software component Generating means, and selectively combining the module of the non-common function part generated by the non-common function generating means and the module of the common function part belonging to any one of the categories stored in the common function storing means. To make a computer function as a component generation means for generating software components A computer-readable recording medium characterized by recording a program.