JP5151792B2 - Distributed development management program - Google Patents

Description

  The present invention relates to a distributed development management program that allows a development management computer to manage common function call names that are commonly called by a plurality of program modules constituting a development target program product in a distributed program development environment. .

  As program products become larger in scale, it is common to develop them in a distributed development environment. Here, the distributed development environment means that an administrator who is responsible for the development of the entire program product determines a predetermined specification, and in accordance with such specification, develops each program module that constitutes the program product into individual development groups. This is a development form in which the development target program is completed by consigning and collecting the programs completed by each development group. The manager and the development group may be a product planning department and a development group in the same company, or may be an orderer company and a contractor company.

Along with the specifications determined in such a distributed development environment, the administrator uses each development group with data commonly used for each program module, that is, common functions (functions, program modules, subroutines, subprograms, etc.) Provided. Therefore, each development group recognizes the contents of these common functions, and if they want to use any of the common functions in the program module that they are developing, A call statement including a name may be described.
JP 2005-158030 A JP 2002-82802 JP JP-A-10-254684

  As described above, the common functions provided by the administrator to each development group are those prepared by the administrator in the previous stage of developing the program module. As it progresses, its contents may not meet the requirements of the program module being developed. In this case, the program module needs to satisfy the request by modifying the common function.

  And if all of the program modules developed by other development groups are convenient, such specifications can be changed by overwriting the original common functions with the modified common functions. Development can be continued without having to

  On the other hand, if such modification is inconvenient for some or all program modules developed by other development groups, the original common function is not overwritten by the common function after modification. They must coexist as separate and independent entities.

In this case, a new common name is assigned to the common function after modification, and the new common name is called by the new name. However, for many of the program modules being developed by other development groups, such modifications are convenient, but when the number of program modules for which such modifications are inconvenient remains slightly, the original name is used for the common function after modification. If you add a new name to the common function before the modification, there is a possibility that the influence amount (the effort of additional work) of all development groups due to the name change can be suppressed.

  In the conventional distributed development environment, there is no known method for calculating the difference in the amount of influence depending on whether the original name is inherited by the old or new common function. When a proposal is made by some development groups, the manager and representatives of each development group meet together to discuss whether the original name should be transferred to the old or new common function. I had to do it. As a result, there may have been a problem that the progress of the work is delayed or the additional work is unnecessarily increased due to a judgment error.

  Therefore, when the new and old common functions coexist due to the modification of the common function, this proposal is designed so that the total sum of the effects on all program modules entrusted to each development group is minimized. It is an issue to provide a distributed development management program that can determine whether a new name should be given to a common function of a version.

  Whether the distributed development management program to which this proposal is applied uses the version before or after the change of the common function for each program module that uses any common function for the computer The amount of influence caused by the name change of the common function that occurs in all program modules for which selection information is acquired and the version before the change is selected, and all the versions that are selected to use the version after the change are selected The amount of influence caused by the name change of the common function occurring in the program module is calculated, and the version selected for the program module on the side where the calculated degree of influence is reduced is determined as a new name assignment target.

  As described above, the names of the common functions of the selected version are the original names of the program module group selected to use the version before the change and the program module group selected to use the version after the change. When the name is changed to a new name, the degree of influence that occurs in all the program modules belonging to the program module group is calculated. Then, a version having a smaller calculated influence degree is determined as a new name assignment target. As described above, since the version having the smallest degree of influence is automatically determined as a new name assignment target, the sum of the degree of influence occurring in all program modules under development can be minimized. In addition, since it is not necessary for the persons in charge of each development group to meet together, it is possible to prevent delays in the work progress caused by this.

  In the present plan, the effect on the program module is, for example, a description change of a call statement of a common function in the source program, a recompilation associated therewith, and a labor required for a retest after the recompilation. Of course, the change in the description of the source program can be regarded as having a small influence if a tool that automatically performs this change is available. If there is such a premise, it is possible to exclude the pre-compiled program module from the target of calculating the influence degree. In addition, as the number of executions of a test against a compiled object program increases, the amount of time required for retesting increases. Therefore, the amount of influence can be calculated by multiplying the number of test executions by a predetermined weight. It is. Also, if the effort per test execution is greater than the effort required for recompilation, the weight multiplied by the number of test executions may be made larger than the amount of influence by one recompilation.

  In the present plan, common functions refer to functions, program modules, subroutines, subprograms, and the like.

According to the proposal configured as described above, when the new and old common functions coexist due to the modification of the common function, the new name is given to the common function before the change and the new name to the common function after the change. Is automatically calculated for each program module entrusted to each development group, and based on the comparison results, all program modules entrusted to each development group are calculated. It is possible to determine whether a new name should be given to the common function of either the old version or the old version so that the total sum of the degree of influence is minimized.

  Hereinafter, embodiments of the present plan will be described based on the drawings.

<System configuration>
FIG. 1 is a block diagram showing a schematic configuration of a network system constituting a program distributed development environment. As shown in FIG. 1, this network system includes a single development management system 1 and a plurality of development group systems 2 connected to each other via a network NW. Among these, the development management system 1 is a computer having an operation authority by an administrator who is responsible for development of the entire development target program product. The system 2 of each development group is installed in a development group entrusted with development of some program modules from the developer according to the specifications of the development target program product, and is operated by a person in charge of the development group. It is a computer.

  First, as the network NW, when the administrator and each development group belong to the same company, an in-company LAN (Local Area Network) can be used, and a part or all of the development groups are different companies. In some cases, the Internet can be used.

  Next, the system 2 of the development group is a computer having a normal configuration having a network connection function. From the CPU 24, the display 25, the input device 26, the RAM 27, the network adapter 28, and the hard disk 20 connected to each other through the bus B, It is configured.

  Among these, a development program source storage area 21, a compilation status storage area 22, and a test execution status storage area 23 are secured in the hard disk 20.

  Among these, the development program source storage area 21 is an area for storing a source program file (source file) being developed and completed for each program module whose development has been outsourced to the development group.

  The compilation status storage area 22 is an area for storing an object program file (object file) that is a result of compiling a completed source program.

  The test execution status storage area 23 is an area for storing the number of times the test is executed on the object program using a test tool such as the COBOL COUNT function.

  The location information (path) of the development program source storage area 21, the compilation status storage area 22, and the test execution status storage area 23, and the latest files or information must be stored in the areas 21 to 23, respectively. It is stipulated in the specifications that the administrator issues to the development group. Therefore, the person in charge of each development group uses the input device in accordance with the program executed by the CPU 24 each time a file or data to be newly stored in each of the areas 21 to 23 is generated or is updated. The latest file or data is read and stored in the corresponding areas 21 to 23.

These storage and update processes may be automatically performed according to a program executed by the CPU 24. Further, the program executed by the CPU 24 responds to the development management system 1 with files or information stored in the areas 21 to 23 in response to a request received from the development management system 1. Further, the program executed by the CPU 24 compiles the completed source program stored in the development program source storage area in response to the request received from the development management system 1 and compiles the resulting object file into a compilation status. Store in the storage area 22.

  Next, the development management system 1 is a computer system having a normal configuration, and the hardware includes a CPU 10, a RAM 11, a network adapter 12, a display 13, an input device 14, and a hard disk 16 connected to each other by a bus B. It is configured.

  The CPU 10 is a central processing unit that reads a program and executes processing according to the program.

  The RAM 11 is a main storage device in which a work area when the program read from the hard disk 16 by the CPU 10 is read and the CPU 10 executes the above processing is expanded. Here, when the distributed development management program read from the hard disk 16 is read, the use common function change source file specifying means (selection information acquiring means) 31, the name change target specifying means 32, the influence amount are stored on the RAM 11. Each function of the calculation means 33 and the change means 34 is developed. The functions of the use common function change source file specifying unit 31, the name change target specifying unit 32, the influence amount calculating unit 33, and the changing unit 34 will be described in detail later with reference to the flowcharts of FIGS. To do.

  The network adapter 12 is a communication device that terminates the network NW and manages data communication with the network NW.

  The display 13 is a display device for displaying a processing result by the CPU 10.

  The input device 14 includes various input devices such as a drive device, a keyboard, and a pointing device such as a mouse.

  The hard disk 16 is a storage device that stores various programs including the distributed development management program and various data. The various data stored in the hard disk 16 includes a development group management DB (database) 35, an impact determination table 36, a related source file status table 37, and an impact weighted DB 38 that are accessed by the distributed development management program. It is.

  The development group management DB 35 is a database for recording the position information (path) of the development program source storage area 21, the compilation status storage area 22, and the test execution status storage area 23 described above for each development group. . FIG. 2 is a table showing a schematic data structure of the development group management DB 35. As shown in FIG. 2, the development group management DB 35 stores one record for each development group. Each record has a “development group” field for recording the code number of the corresponding development group, and a “development program source storage area” field for recording position information (path) of the development development program source storage area 21. , “Compilation status storage area” field for recording position information (path) of the compilation status storage area 22, “Test execution status storage area” field for recording position information (path) of the test execution status storage area 23 , And a “mail address” field for storing the mail address of the person in charge.

  The influence degree determination table 36 is a table used for comparison of influence degrees by the influence degree calculation means 33. FIG. 3 is a table showing the data structure of this influence determination table 36. As shown in FIG. 3, the influence degree determination table 36 shows the sum of influence degrees (selection = new) calculated for the program modules that call the common function of the version after change, and the common function of the version before change. It has an “influence degree” field for recording the sum of influence degrees (selection = old) calculated for each program module to be called.

  The related source file status table 37 is a table for recording the progress of development of each program module entrusted to each development group. FIG. 4 is a table showing a schematic data structure of the related source file status table 37. As shown in FIG. 4, the related source file status table 37 stores one record for each program module. Each record includes a “source file name” field for recording the name of the source file of the corresponding program module, a “development group” field for recording the code number of the development group, and a source program of the corresponding program module. "Select" field to record whether the new function calls the common function of the new version or (new) the common function of the previous version (old), whether the compilation has not been done yet (not yet) "Compile" field for recording whether or not (completed), "Test execution number" field for reprinting the test execution number recorded in the test execution status storage area 23, "Impact" calculated for the corresponding program module It consists of an “influence” field for recording “degree”. At the stage where each program module is outsourced to each development group, values are written in the “source file name” field and the “development group” field, but the other fields are blank. Note that the value of the “selection” field corresponds to selection information on whether to use the version before or after changing the common function.

  The influence weighting DB 38 is a database that stores weight values used for determination of the degree of influence, which will be described later, by the influence degree calculating means 33 for recompilation and retesting. FIG. 5 is a table showing the data structure of the influence weighted DB 38. As shown in FIG. 5, the influence weighted DB 38 has a “recompile” field for recording a weight value for recompilation and a “retest” field for recording a weight value for retest. doing.

<Data processing flow>
Hereinafter, in the development management system 1 constituting the network system configured as described above, the processing realized by the CPU 10 reading the distributed development program stored in the hard disk 16 (that is, the functions 31 to 34 realized by the CPU 10). Will be described with reference to the flowcharts of FIGS.

  The process shown in the flowchart of FIG. 6 starts when the administrator determines the specifications for the development target program product, issues the specifications to each development group, and stores necessary data in the development group management DB 35.

  In the first step S001 after the start, the CPU 10 waits for a specification change proposal notification from each development group. This specification change proposal notification is sent from the system 2 of each development group to the development management system 1 in accordance with the format defined in the specification issued to each development group by the administrator. This message includes the name, a request to change the common function, and the contents of the changed common function.

In the next S002, the CPU 10 checks whether a specification change proposal notification is received from any of the development groups. If no specification change proposal notification has been received from any development group, the CPU 10 returns the process to S001. On the other hand, when the specification change proposal notification is received from any of the development groups, the CPU 10 advances the process to S003.

  In S003, the CPU 10 extracts the name of the target common function and the contents after the change from the specification change proposal notification received in S002, and displays them on the display 13.

  In the next S004, the CPU 10 checks the content of the specification change proposal, that is, whether or not the changed common specification extracted and displayed in S003 can be adopted according to the instruction from the operator input through the input device 14. . When the operator inputs an instruction not to adopt, the CPU 10 ends the processing by this distributed development program as it is.

  On the other hand, when the operator inputs an instruction to adopt, in S005, the CPU 10 performs a process of specifying the source file of the program module that uses the common function of the revised version after the change proposed. Run.

  FIG. 7 is a flowchart showing the common use function change source file specifying process subroutine executed in S005. In the first step S101 after entering this subroutine, the CPU 10 (usage common function change source file specifying means 31) reads the value of the “development program source storage area” field for each development group from the development group management DB 35, that is, its position. Read information (path).

  In next S102, the CPU 10 (usage common function change source file specifying means 31) searches the development program source storage area 21 in the system 2 of all development groups based on the position information (path) acquired in S101, Get the source file of the program module that uses the proposed common function.

  In the next S103, the CPU 10 (usage common function change source file specifying means 31), the code number of the development group from which the source file was acquired in S102, the name of each source file, and the contents if necessary The change source file selection screen including “” is displayed on the display 13, and the common function (new) of the version before change is used for each source file in each development group or the common function (old) of the version after change is used. The selection is accepted. That is, as shown in FIG. 11, the change source file selection screen has an option button 42 for selecting new or old for each combination of the code number 40 of each development group and the source file name 41 of each source file. A “reference” button 43 for displaying the detailed contents of the source program is displayed in a list. Then, the operator of the development management system 1 checks either the old or new option button 42 for each combination according to the new and old selection results obtained from the person in charge of each development group. This selection screen is displayed on the display 25 of the system 2 of each development group, and the development management system 1 receives the new and old selection results directly input by the person in charge of each development group on this selection screen via the network NW. It may be configured to do so. In any case, when accepting the new / old selection results for the combinations of the code numbers 40 and the source file names 41 of all the development groups, the CPU 10 (usage common function change source file specifying means 31) advances the process to S104.

In the next S104, the CPU 10 (usage common function change source file specifying means 31) generates a related source file situation table 37 as illustrated in FIG. 4A based on the contents selected and input in S103. To do. At this time, the “compile” field, the “test execution count” field, and the “influence” field are not set in the table. When S104 is completed, the CPU 10 (usage common function change source file specifying unit 31)
After completing the subroutine of FIG. 7, the process proceeds from S005 to S006 in FIG.

  In S006, for each common function, the CPU 10 (name change target specifying means 32) executes processing for specifying whether the original name is inherited by the one after the change or the original name is succeeded by the one before the change. To do. FIG. 8 is a flowchart showing the name change target specifying subroutine executed in S006.

  In the first step S201 after entering this subroutine, the CPU 10 (name change target specifying means 32) reads the value of the “compilation status storage area” field for each development group from the development group management DB 35, that is, its position information (path). Read. Based on the read position information (path), the compilation status storage area 22 in the system 2 of each development group is searched, and based on whether there is an object file for each program module specified in S005, It is determined whether or not the source program of each program module has been compiled. Then, the determination result is set in the “compile” field for each program module in the related source file status table 37 (see FIG. 4B).

  In the next S202, the CPU 10 (name change target specifying means 32) reads the value of the “test execution status storage area” field for each development group, that is, its position information (path), from the development group management DB 35. Then, based on the position information (path), the test execution status storage area 23 in the system 2 of each development group is changed to each source file name in which “completed” is set in the “compile” field in the related source file status table 37. Search as a key and get the number of test executions for the object program. Then, the test execution count for each acquired object program is set in the “test execution count” field of the related source file status table (see FIG. 4C).

  In the next S203, the CPU 10 (name change target specifying means 32) changes the name of the version before change to a new name for the proposed common function for each program module outsourced to each development group. An influence degree calculation process is performed for calculating the influence degree and the influence degree when the changed version name is changed to the new name.

  FIG. 9 is a flowchart showing the influence degree calculation subroutine executed in S203. In the first step S301 after entering this subroutine, the CPU 10 (influence calculation means 33) resets the variable n for specifying the processing target record in the related source file status table 37 to the initial value “1”.

  Subsequently, the CPU 10 (influence degree calculation means 33) executes a loop process of S302 to S309 in order to calculate the influence degree for each record of the related source file status table 37. In the first step S <b> 302 after entering this loop process, the CPU 10 (influence calculation means 33) reads the nth record from the related source file status table 37.

  In next step S303, the CPU 10 (the influence degree calculating unit 33) acquires the value of the “compile” field from the nth record read in step S302.

In next step S304, the CPU 10 (influence calculation means 33) checks whether or not the value read in step S303 is “completed”. If the value is “not yet” or not set, the record 10 can be regarded as having little influence due to the name change because it has not been compiled. Therefore, the CPU 10 (the influence degree calculating means 33) does not change the process as it is. Proceed to S308. On the other hand, if the value is “done”, since the record is already compiled, it can be considered that the influence due to the name change is large. Therefore, the CPU 10 (impact calculation unit 33) performs the process in S30.
Proceed to 5.

  In S <b> 305, the CPU 10 (the influence degree calculating unit 33) reads the value corresponding to “compile” from the influence degree weighting DB 38, and uses the read value as the “influence degree” of the nth record in the related source file status table 37. Set in the field.

  In next step S <b> 306, the CPU 10 (the influence degree calculation unit 33) acquires the value of the “test execution count” field from the n-th record of the related source file status table 37.

  In next step S307, the CPU 10 (the influence degree calculating unit 33) reads the value corresponding to “retest” from the influence weighting DB 38, and sets the read value to the value of the “test execution count” field acquired in step S306. The product calculated by multiplication is added to the value of the “influence” field of the nth record in the related source file status table 37. When S307 is completed, the CPU 10 (influence calculation unit 33) advances the process to S308.

  In S308, the CPU 10 (influence calculation means 33) increments the variable n by one.

  In next step S309, the CPU 10 (the influence degree calculating unit 33) checks whether or not the processing in step S302 and subsequent steps has been completed for all the records in the related source file status table 37. If the processing has not yet been completed for all records, the CPU 10 (influence calculation means 33) returns the processing to S302.

  On the other hand, when the process has been completed for all the records, the CPU 10 (influence degree calculation means 33) completes this influence degree calculation process subroutine and returns the process to the routine of FIG.

  In the routine of FIG. 8 in which the process is returned, the CPU 10 (name change target specifying means 32), in S204 following S203, the value of the “selected” field among all the records in the related source file status table 37 is “old”. However, the sum of the values in the “influence” field is calculated, and the calculated sum is set in the “influence” field of the record whose “selection” field in the influence determination table 36 is “old”. .

  In the next step S205, the CPU 10 (name change target specifying means 32) calculates the sum of the values in the “influence” field of all records in the related source file status table 37 whose “selection” field value is “new”. The calculated sum is set in the “influence degree” field of the record in which the value of the “selection” field in the influence degree determination table 36 is “new”. When S205 is completed, the CPU 10 (name change target specifying means 32) ends this name change target specifying process subroutine and returns the process to the main routine of FIG.

  In the main routine of FIG. 6 in which the process is returned, the CPU 10 executes the change process in S007 following S006. FIG. 10 is a flowchart showing the change processing subroutine executed in S007. In the first step S401 after entering this subroutine, the CPU 10 (changing means 34) compares the values of the “effect level” fields of the two records of the influence level determination table 36, and sets the value of the smaller “selection” field. , Set the variable “New name target (new name assignment target)”.

In next step S <b> 402, the CPU 10 (changing unit 34) displays a message for prompting the input of a new name on the display 13 and waits for the operator to input some new name through the input device 14. And if an operator inputs a new name, this will be received. Then, the variable “new name object” among the change target common function of the version before update stored in the development management system 1 and the change target common function of the version after update extracted from the specification change proposal notification in S003. The name of the one corresponding to is changed to the received new name, and the name of the other (limited to the changed common function after update) is changed to the original name of the changed common function.

  In next step S403, the CPU 10 (changing unit 34) specifies all records in which the value of the “selection” field in the related source file status table 37 matches the variable “new target name”.

  In the next S404, the CPU 10 (changing means 34), for each record specified in S403, the value of the “development program source storage area” field corresponding to the value of the “development group” of that record, that is, the position Information (path) is read from the development group management DB 35, the read value, that is, the development program source storage area 21 indicated by the position information (path) is accessed, and the value of the “source file name” field of the record indicates The source file is read, and the name of the change target common function described in the source program in the read source file is changed to the new name accepted in S402. When this process is executed for all the records specified in S403, the CPU 10 (changing unit 34) advances the process to S405.

  In S405, the CPU 10 (changing unit 34) selects all the records identified in S403 that have a “compiled” field value of “completed” and a “test execution count” field value of zero or more. Sort out. Then, for each selected record, the value (mail address) of the “mail address” field corresponding to the value of “development group” of the record is read from the development group management DB 35, and the record is sent to the read mail address. An e-mail including a recompile instruction and a retest instruction for the source file indicated by the value of the “source file name” field is notified. In this case, the CPU 10 (changing unit 34) may directly send a command for instructing recompile and retest to the source file to the system 2 of the development group. When this process is executed for all selected records, the CPU 10 (changing unit 34) advances the process to S406.

  In S406, the CPU 10 (changing means 34), among all the records specified in S403, has a “compiled” field value “completed” and a “test execution count” field value not set or zero. Select all. Then, for each selected record, the value (mail address) of the “mail address” field for the “development group” value of that record is read, and the “source file name” field of that record is read to the read mail address. An e-mail including an instruction to recompile the source file indicated by the value of is sent. In this case, the CPU 10 (changing unit 34) may directly send a command for instructing the source file to be recompiled to the system 2 of the development group. When this process is executed for all selected records, the CPU 10 (changing unit 34) advances the process to S406. In S406, unlike S405, the development group is not instructed to perform a retest. This is because the development group to be contacted in S406 is originally scheduled to execute the test. When S406 is completed, the CPU 10 (changing means 34) ends this changing process subroutine, returns the process to the main routine of FIG. 6, and ends this main routine.

<Operation of Embodiment>
When all of the above processing is completed, if there is a specification change proposal notification for any common function from some development groups, as long as the proposal is adopted (S004: YES), the common version of the version before the change Since the original name is inherited to one of the functions and the common function after the change, and the new name is given to the other (S404), the new and old versions of the common function can coexist. Thus, each development group can describe the common functions of both the old and new versions to be arbitrarily selected and called when creating the source program of the program module for which development is entrusted.

  However, if each program module has been developed until a certain point in time, the call target is changed from the common function of the version before the change to the common function of the version after the change, the common function of the version after the change If a new name is given, the description of the call statement of the common function in the source program must be rewritten. Similarly, even if the call target remains the common function of the version before the change, if a new name is given to the common function of the version before the change, the description of the call statement of the common function in the source program is Must be rewritten. In particular, when the specifications of the common function are changed after the source program is completed and compiled, the source program description is changed, the source program is recompiled, and the recompiled object program is tested. Therefore, the influence on the entire work amount is great.

  Therefore, in this embodiment, in order to minimize such influence, the common function of the version before the change is changed according to the selection status of the common function of any version of the program module in each development group (S005, S103). If a new name is given to the program, the total sum of influences to be generated in all program modules developed by each development group is calculated (S006, S203, S204), and the new name is added to the common function of the revised version. If given, the total sum of influences that should occur in all program modules developed by each development group is calculated (S006, S203, S205). A new name is assigned (S007, S401, S402). Therefore, even if there is a change in the specifications of the common function, and the new version of the common function is adopted by a development group other than the proposal source, the new function of the common function is minimized so that the influence on the whole is minimized. Since the version to which the name is assigned is determined, the influence of the change can be minimized.

  In the present embodiment, when it is determined whether to assign a new name (whether to inherit the original name) to the old or new version of the common function to be changed (S401, S402), the new name is assigned. The application of adopting the common function of the version that has become the application has been applied (S103) The description of the call statement of the common function in the source program of the program module is automatically rewritten to target the new name (S404). Accordingly, since it is considered that the influence of the name change of the call target common function on the source program before compilation is still small, the uncompiled program module is excluded from the above-described influence degree calculation targets.

  Furthermore, recompilation is instructed to the development group that has applied for the adoption of the common function of the version to which the new name is to be given (S103).

Further, when a test is being executed on the object program of the program module, an instruction to execute the test is performed the same number of times as performed so far (S405). As described above, for the program module in which the description of the call statement is changed, the same number and contents of the tests as the executed tests must be re-executed after recompilation. Therefore, the greater the number of test executions, the greater the impact of the name change of the call target common function. Therefore, in the above-described influence degree calculation, the influence degree is calculated by multiplying the number of test executions by the weight value (S307). Moreover, since the amount of work for this retest is larger than that for recompilation, it is possible to calculate a realistic influence degree by making the weight for retest larger than the weight for one recompilation.
(Appendix 1)
In a distributed development environment in which a plurality of development groups are in charge of developing program modules that can call and use common functions, in order to manage names for calling the common functions,
Selection information acquisition means for acquiring selection information on whether to use the version before or after the change of the common function for each program module that uses any of the common functions;
The amount of influence caused by the name change of the common function that occurs in all program modules selected to use the version before change, and the common that occurs in all program modules selected to use the version after change An influence amount calculating means for calculating an influence amount due to a function name change, and
A distributed development management program for causing a version selected for a program module having a smaller influence degree calculated by the influence amount calculating means to function as a changing means for determining a new name assignment target.
(Appendix 2)
The distributed development management program according to appendix 1, wherein the influence amount calculation means calculates the influence amount based only on a program module that has been compiled from a source program into an object program.
(Appendix 3)
The influence amount calculation means calculates the influence amount as the amount of work required for recompilation and the amount of work required to re-execute the already executed test for each program module that has been compiled from the source program to the object program. The distributed development management program according to appendix 2, characterized by:
(Appendix 4)
The amount of influence calculation means calculates the amount of influence by weighting so that the amount of work required per test is larger than the amount of work required for the recompilation. Distributed development management program.
(Appendix 5)
The influence amount calculating means, for each program module, access a database recording the presence / absence of compile execution and the number of test executions, and read the presence / absence of compile execution and the number of test executions for each program module, The distributed development management program according to attachment 3, wherein the influence amount is calculated.
(Appendix 6)
The change means changes the name of the common function in the call statement in the source program of each program module selected to use the version determined to be a new name assignment target to a new name. 2. A distributed development management program according to 2.
(Appendix 7)
The changing means changes the name of the common function of the version determined to be a new name assignment target to the new name, and if the other version is the changed common function, the original name is assigned to the changed common function. The distributed development management program according to appendix 1, which is given.

Block diagram showing schematic configuration of development management system and development group system Table showing data structure of development group management DB Table showing the data structure of the impact determination table Table showing data structure of related source file status table Table showing data structure of impact weighted DB Flow chart showing processing by development management program The flowchart which shows the content of the use common function change source file specific process subroutine performed by S005 of FIG. The flowchart which shows the content of the name change object specific process subroutine performed in S006 of FIG. The flowchart which shows the content of the influence degree calculation process subroutine performed in S203 of FIG. The flowchart which shows the content of the change process subroutine performed by S007 of FIG. Figure showing the change source file selection screen

Explanation of symbols

1 Development Management System 2 Development Group System 10 CPU
11 RAM
14 Input device 16 Hard disk 31 Common use function change source file identification means 32 Name change target identification means 33 Influence amount calculation means 34 Change means 35 Development group management DB
36 Influence determination table 37 Related source file status table 38 Influence weighted DB

Claims (5)

In a distributed development environment in which a plurality of development groups are in charge of developing program modules that can call and use common functions, in order to manage names for calling the common functions,
Selection information acquisition means for acquiring selection information on whether to use the version before or after the change of the common function for each program module that uses any of the common functions;
The amount of influence caused by the name change of the common function that occurs in all program modules selected to use the version before change, and the common that occurs in all program modules selected to use the version after change An influence amount calculating means for calculating an influence amount due to a function name change, and
A distributed development management program for causing a version selected for a program module having a smaller influence degree calculated by the influence amount calculating means to function as a changing means for determining a new name assignment target. 2. The distributed development management program according to claim 1, wherein the influence amount calculation means calculates the influence amount based only on a program module that has been compiled from a source program into an object program. The influence amount calculation means calculates the influence amount as the amount of work required for recompilation and the amount of work required to re-execute the already executed test for each program module that has been compiled from the source program to the object program. The distributed development management program according to claim 2, wherein: The change means changes a name of the common function in a call statement in a source program of each program module selected to use a version determined as a new name assignment target to a new name. Item 3. The distributed development management program according to item 2. The changing means changes the name of the common function of the version determined to be a new name assignment target to the new name, and if the other version is the changed common function, the original name is assigned to the changed common function. The distributed development management program according to claim 1, which is given.

Images