JP2001100998A - Computer system - Google Patents

Abstract

PROBLEM TO BE SOLVED: To notify a developer of whether or not some of submodules needed to execute program codes has a characteristic problem of incompatibility, etc. SOLUTION: This system comprises one main module, a program code consisting of one or more submodules having a function of informing an executing person of a characteristic message as to the execution of itself, and a server system which has a function of saving the respective submodules and transmitting them through a network. When one program code is executed, a message that the submodule, which the program code utilizer, has is reported to the executing person.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

The present invention relates to one or a plurality of first computers for executing a program code comprising one main module and one or a plurality of sub-modules; A sub-module group referred to by the same name as the module and inputting the same parameter is stored, and in response to a request from the first computer,
The requested one or more sub-modules into the first
And a second computer for transferring to a second computer.

[0002]

2. Description of the Related Art In a computer capable of executing an arbitrary program code on an arithmetic unit, when a certain program code is to be executed, all modules (including a main module) used by the program code are used.
Is distributed or copied as a single program package, and the method of introducing it is different, considering that there are many opportunities to use the same sub-module (commonly called a library) between different program codes. A common sub-module file will be included in the file of the program package,
There is a problem that a useless load is applied when distributing or copying the program package, and a storage area of the auxiliary storage device into which the program is installed is uselessly increased.

Therefore, only one sub-module which is likely to be commonly used among many program codes is stored in a computer in advance, and the program code is executed when the program code is executed. By combining the main module and sub-modules stored for each code with those required for execution from the pre-stored sub-modules and combining them, the entire program code can be dynamically constructed. By executing the method, a method of eliminating the useless load and the useless storage area of the auxiliary storage device as described above is adopted in many computer systems. This is commonly called a dynamic link library.

Further, in recent years, dynamic link libraries having the following features, such as the Java language, have become popular. 1) By preparing different sub-modules for different computers, and performing the same function by executing the same parameter as an input for each sub-module referred to by the same name, The same main module can be executed on each of different computers.
2) By making the specifications of the sub-modules publicly available, different developers can develop sub-modules of the same specifications that can be executed by the same computer. 3)
By publishing the specifications of the sub-module to the public prior to its own development, it is possible to proceed with the development of the main module and the development of the sub-module at the same time.

[0005]

However, the computer system employing the above method has the following problems. That is, of the sub-modules stored in advance on different computer systems, the sub-modules which are referred to by the same name and have the same parameters as input are different in the function or side effect between the computer systems. appear. This is generally called incompatibility.

[0006] Even if the sub-modules are referred to by the same name and have the same parameters as inputs, the development times of the sub-modules are different, the sub-modules contain non-common defects (bugs), This is because there is a difference in the function or side effect of another sub module or operating system to be used.

Therefore, a developer of a program code presupposes at the time of development as a function or a side effect of a sub-module used when executing the program code, and a function of a sub-module actually executed. If there is a difference between the function and the side effect, there is a problem that the operation intended by the developer of the program code cannot be realized.

On the other hand, if the developer can know which sub-module has incompatibility at the time of development, it is possible to adopt some sort of avoidance measure. Due to the large number of sub-modules, the frequency of finding new incompatibilities, and the presence or absence of incompatibilities depending on the value of input parameters, the usual document notification to the developer However, there is a problem that the incompatibility is hardly recognized, and the work load of the developer is increased.

SUMMARY OF THE INVENTION The present invention has been made in view of such a problem, and has as its object the purpose of executing any one of sub-modules necessary for executing a program code.
It is an object of the present invention to provide a computer system capable of notifying a developer or the like whether a module has a specific problem such as incompatibility or not.

[0010]

SUMMARY OF THE INVENTION In order to achieve the above object, the present invention provides, when a certain sub-module is executed, a developer of a program code using the sub-module. The sub-module itself has a function of notifying a message explaining the content of the incompatibility specific to the module.

Specifically, one main module and one main module
One or more first calculators executing program code consisting of one or more sub-modules, referenced by the same name as said sub-modules,
A second computer that stores a group of sub-modules for inputting the same parameters, and transfers one or more requested sub-modules to the first computer in response to a request from the first computer; In the computer system provided, the first computer executes the program code including an input device, a sub-module acquired from the second computer, and a main module stored in advance to execute the first computer. Means for receiving the fault content of the sub-module obtained from the second computer from the input device, and notifying the input fault content to the second computer; and a sub-module obtained from the second computer in advance. When the program code consisting of the stored main module is executed, the error content message is Means for checking whether or not the error message is included, and displaying the error content message if the error message is included, wherein the second computer determines the error content notified from the first computer. Means for storing the data in a sub-module.

Further, the first computer is referred to by a sub-module having a certain function and the same name, receives the same parameter, has the same function, and notifies a message specific to the sub-module. Switching means for arbitrarily designating and executing any of the sub-modules having a function to perform the function. Further, the second computer further includes means for notifying the first computer when any of the sub-modules in the sub-module group stored therein has been updated or newly added. It is characterized. In addition, the first computer further includes means for switching a message to be notified according to the value of the input parameter.

[0013]

Embodiments of the present invention will be described below in detail with reference to the drawings. FIG. 1 is a system configuration diagram showing one embodiment of a computer system to which the present invention is applied. In FIG. 1, reference numeral 101 denotes a server device (corresponding to a second computer) having means for transmitting data via a network 110; 102, an auxiliary storage device for storing source codes of sub-modules; An auxiliary storage device 104 for storing the module is an arithmetic device for executing a process of generating a sub-module from the source code of the sub-module stored in the auxiliary storage device 102.

Reference numeral 105 denotes a client device having means for receiving data via the network 110; 106, an arithmetic device for executing a program code constituted by combining a main module and a plurality of sub-modules; Is a display device for displaying a character output from a program code executed on the arithmetic unit 106, 108 is an auxiliary storage device for storing a main module, and 109 is an auxiliary storage device for storing a sub-module Device.

Reference numeral 110 denotes a network for connecting the server device 101 and the client device 105. 1
11 is a computer for a user of the program code to execute the program code, 112 is an arithmetic unit for executing a combination of a main module and a plurality of sub-modules, and 113 is for storing the main module The auxiliary storage device 114 is an auxiliary storage device for storing sub-modules. Here, 105-1
09 (corresponding to the first computer) is a computer used by a program developer here.
The part consisting of 14 is a computer used by general users.

FIG. 2 shows an example of a source code of a sub-module stored in the auxiliary storage device 102 attached to the server device 101. Reference numeral 201 denotes a display of the contents of a fault existing in this sub-module. Apparatus 10
7 is a portion describing the process to be output, and 202 is a portion describing the original process of this sub-module.

FIG. 3 shows an example of the source code of the main module. Reference numeral 301 denotes a part describing a sub module calling process. FIG. 4 shows an example of message characters output to the display device 107 of the client device 105 when the main module shown in FIG. 3 is executed.

FIG. 5 is a flow chart showing the processing contents of the server 101 for notifying the contents of the failure of the sub-module. In FIG. 5, first, a report is received from a client device 105 used by a developer of a sub module as to which part in the source code of which sub module has a failure (step 501).
The content of the fault is input by the program developer from an input device such as a keyboard of the client device 105 and transmitted to the server device 101 via the network 110. Next, as shown in FIG. 2, the contents of the failure are displayed at the place where the failure has been reported in the source code stored in the auxiliary storage device 102 corresponding to the sub-module for which the report was received, as shown in FIG. Add the code (step 50
2). Next, this corrected source code is
04 to a sub module (step 5
03). Next, the resulting sub-module is replaced with the corresponding unmodified sub-module stored in the auxiliary storage device 103 (step 504).

FIG. 6 is a flowchart showing processing on the client device 105 side for developing and executing a program code using a sub-module. First,
In the client device 105, the main module converted from the source code as shown in FIG. 3 developed by the developer is stored in the auxiliary storage device 108 (step 6).
01).

Next, the main module stored in the auxiliary storage device 108 and the sub-module previously stored in the auxiliary storage device 109 are loaded into the arithmetic unit 106 (step 602). Then, the program code combining the program and the sub-module is executed (step 603). The result of the execution is checked to confirm that there is no obstacle to the execution using at least the sub-module previously stored in the auxiliary storage device 108 on the arithmetic device 106.

Next, the sub-module stored in the auxiliary storage device 103 of the server device 101 is acquired by the client device 105 via the network 110 and stored in the auxiliary storage device 109.
08 and the sub-module acquired from the server device 101 and stored in the auxiliary storage device 109 are loaded into the arithmetic device 106 (step 604), and the main module and the sub-module are loaded. The program code combined with the module is executed (step 605). As a result, if there is a failure in the used sub-module, the processing according to the description 201 of the failure content output in FIG. 2 is executed, and the content of the failure is output to the display device 107.

Here, in the course of execution, the person in charge of development refers to the display device 107 to check whether or not a character indicating the content of the fault is displayed by the used sub-module itself (step 606). if,
If a failure that has a significant effect on the execution of this program code is displayed, the main module stored in the auxiliary storage device 108 is modified so that the failure can be avoided (steps 607 and 608). . If, at step 607, no failure is indicated that has a significant effect on the execution of this program code,
The main module stored in the auxiliary storage device 108 is copied and stored in the auxiliary storage device 113 (step 609).

Next, the main module stored in the auxiliary storage device 113 and the sub-module previously stored in the auxiliary storage device 114 are loaded into the arithmetic unit 112 (step 610). Program consisting of a combination of
The code is executed on the arithmetic unit 112 (step 61)
1). In the arithmetic unit 112, only the processing inherent in the sub-module in FIG. 2 is executed.

Therefore, according to this embodiment, it is possible to determine whether any of the sub-modules necessary for executing the program code has a specific problem such as incompatibility or not. -The developer can be notified at the same time as the execution of the code, so that the burden on the developer can be reduced.

In the above embodiment, the client device 105 includes a sub module having a certain function,
A switching means for arbitrarily specifying and executing any one of the sub-modules which are referred to by the same name, have the same parameters, have the same function, and further have a function of notifying a message specific to the sub-module. With this arrangement, it is possible to switch between normal execution and execution during debugging.

When any of the sub-modules stored in the server 101 is updated (or modified) or newly added to the server 101, the client 105 automatically receives the update. By providing means for notifying the developer, the developer can promptly implement a new response in accordance with the notification.

Further, by providing the client device 105 with means for switching the message to be notified according to the value of the input parameter, even if the same sub-module has different incompatibility due to different input parameters, The incompatibilities specific to the parameters that the program code to be developed inputs to the sub-module can be known.

Further, in the above-described embodiment, an example has been described in which only one client device 105 is used by the program developer. However, the same applies to a case where a plurality of devices are used. In addition, the present invention can be applied to an application that is connected to the world via the Internet via a network and is activated by a plug-in on a browser of each terminal to perform display, analysis, and processing.

[0029]

As described above, according to the present invention, the following effects can be obtained. 1) When a developer develops a program code that uses a certain sub-module, the incompatibility found for the sub-module can be known by actually executing the program code. . 2) After taking measures to avoid incompatibility of the used sub-modules, it is possible to select a normal module that does not notify a message and execute the program code. 3) By using a sub-module having a function of notifying the latest message regarding the incompatibility, all incompatibilities to be avoided at the time of development can be known. 4) Even if the same sub-module has different incompatibilities due to different input parameters, the program code to be developed can know the specific incompatibility of the parameters input to the sub-module.

[Brief description of the drawings]

FIG. 1 is a configuration diagram showing an embodiment of a computer system to which the present invention has been applied.

FIG. 2 is an explanatory diagram showing an example of a source code of a sub module.

FIG. 3 is an explanatory diagram showing an example of a source code of a main module.

FIG. 4 is a diagram illustrating an example of an output result of a display device at the time of execution.

FIG. 5 is a flowchart showing a process on the server device side for notifying a failure content of a sub module.

FIG. 6 is a flowchart showing processing on the client device side for developing and executing a program code using a sub-module.

[Explanation of symbols]

101: server device (second computer), 102, 103
... Auxiliary storage device, 105 ... Client device (first computer), 107 ... Display device, 108,109 ...
Auxiliary storage device, 111 ... computer.

Claims (4)

[Claims] 1. One or more first computers executing a program code composed of one main module and one or more sub-modules,
A sub-module group that is referred to by the same name as the sub-module and inputs the same parameter is stored, and in response to a request from the first computer, one or more requested sub-modules are stored in the first sub-module. And a second computer for transferring the data to the second computer, wherein the first computer has an input device, a sub-module obtained from the second computer, and a main module stored in advance. Means for receiving, from the input device, the failure content of the sub-module obtained from the second computer by executing the program code comprising the module, and notifying the second computer of the input failure content; When executing a program code including a sub-module obtained from the second computer and a main module stored in advance, Check whether the acquired sub-module contains a failure content message,
Means for displaying the failure content message when the information is included, wherein the second computer includes means for storing the failure content notified from the first computer in a corresponding sub-module. A computer system, comprising: 2. The first computer notifies a sub-module having a certain function and a message which is referred to by the same name, has the same parameter, has the same function, and is unique to the sub-module. A switching module for arbitrarily designating any one of the sub-modules having a function to execute the sub-module.
Computer system as described. 3. The second computer notifies the first computer when any of the sub-modules stored in the second computer is updated or newly added. 2. The method according to claim 1, further comprising:
Or the computer system according to 2. 4. The computer system according to claim 1, wherein said first computer further comprises means for switching a message to be notified according to the value of the input parameter.