JP2000339147A - System for supporting estimation of software development costs and recording medium - Google Patents

Abstract

PROBLEM TO BE SOLVED: To improve the precision of estimation by preparing estimation corresponding to various kinds of conditions under development. SOLUTION: A relation approximate formula database 15 stores a relational approximate formula preliminarily calculated from corresponding result information for each factor information. Then, a controller 8 receives the input of a condition under development and specification information, and calculates the number of FP(function points), and calculates the estimated number of processes by assigning the calculated number of FP to the relational approximate formula corresponding to the factor information matching with the condition.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to an estimation support system for calculating the number of processes based on a specification based on a software function quantity.

[0002]

2. Description of the Related Art When developing software, a specification is created based on required specifications provided by a customer, and the number of processes according to the development ability of the user is estimated based on the specification. And development costs, such as orders received. Here, the main methods for obtaining the estimation of the number of steps include the LOC method (Lines of Code method) and the software function quantity method (FP method; Function Point method). In the following description, the estimated number of steps is represented as “estimated number of steps” to distinguish it from the actual number of steps.

[0003] The LOC method is a method of estimating the number of production KLs (the number of lines of a program) and converting it into an estimated number of processes.
The P method estimates the number of records in a file and the number of inputs and outputs as the number of functions (FP number; Function Point number) without using the number of program lines or the number of documents, and uses this FP number as the estimated number of processes. How to convert. The LOC method is not suitable for GUI design because the number of production KLs cannot be immediately estimated from the specification of a program using a graphical user interface (GUI). On the other hand, the number of records in the file and the number of FPs as
In recent years, the FP method suitable for GUI design has been attracting attention because it can be roughly estimated from the specification of a program that uses FP.

The process of calculating the estimated number of steps for software development using the FP method will be specifically described below.
The number of FPs is a fixed numerical value determined according to the number of files indicated in the specification, the number of display items for each display screen, the number of form items for printing, and the like. For example, the input file, output file, input / output file, input display item, output display item, input / output display item, menu display item, and item of each function classified into eight types of forms used for each processing. A table summarizing the number of (hereinafter referred to as "function items") and the processing difficulty for each of them is created based on the specification, and the complexity is evaluated based on the number and the processing difficulty, For each function item type (such as “input file”), a numerical value (FP number conversion value) determined in advance according to each evaluation (“simple” etc.) is calculated for each file number, display item number, form number, etc. The value obtained by multiplying the number of items and further accumulatively adding the number is defined as the FP number. Here, the number of function items corresponds to, for example, the number of data read in the input file.

[0005] Specifically, the number of each function item is evaluated in three stages of "small", "normal", and "many", and similarly, the difficulty level of the processing is "easy", "normal", "difficult". Is evaluated in three steps. As for the complexity, a table (complexity matrix) indicating the complexity with respect to the number of function items and the difficulty of processing is determined in advance as shown in FIG. Simple, ordinary, and complex
Evaluate on a scale. Similarly, the FP number conversion value is shown in FIG.
(FP number calculation table) shown in FIG. FIG. 11 is an explanatory diagram illustrating an example of a table for calculating a software function amount.

Next, a conventional estimation support system will be described. FIG. 12 is a configuration block diagram of a conventional estimation support system, and FIG. 13 is an explanatory diagram showing input items in the conventional estimation support system. As shown in FIG. 12, the conventional estimation support system includes the input device 1 and the input device 1 shown in FIG.
, A control device 2 having a complexity matrix and an FP number calculation table, a display device 3, and a factor database 4. Further, the control device 2 includes an FP
It includes a number calculation unit 5 and an estimated process number calculation unit 6. The factor database 4 stores, as performance information, a set of the number of FPs in a past specific development project and the corresponding actual number of processes for each piece of information (factor information) representing a tool used for development. .

[0007] The control device 2 shows, for example, an input file, an output file, an input / output file, an input display item, an output display item, an input / output display item, a menu display item, and a form from the input device 1 as shown in FIG. As described above, the number of the function items and the degree of difficulty of the process are input. Specifically, in FIG. 13, for each process, for example, in the process of “screen”, the processes of screens 1 to 7 are performed, and in the process of screen 1, the number of items is “normal”, and the difficulty of the process is “ This indicates that the menu display item "normal" is displayed.

The control unit 2 evaluates the complexity in three stages of "simple", "normal", and "complex" based on the complexity matrix based on the complexity matrix for each process.
For example, in the processing of the screen 1, since the number of items is “normal” and the difficulty level of the processing is “normal”, the complexity is evaluated as “normal” from the complexity matrix shown in FIG. You. Further, the FP number calculation unit 5 of the control unit 2 counts the number of each function item for each complexity. Specifically, in FIG. 13, the input file (F
The number of I) is counted as "2". FP of control device 2
The number calculation unit 5 adds the numerical value thus counted to F
The corresponding FP number conversion value set in the P number calculation table is multiplied, and the sum thereof is calculated. Specifically, when the number of simple input files is “2”, the number of ordinary input files is “5”, and the number of complex input files is “4” according to the complexity, FIG. As shown in the FP number calculation table in b), the FP number conversion value for a simple input file is “3”, the FP number conversion value for an ordinary input file is “5”, and the FP number conversion value for a complex input file is “5”. Since it is “8”, 2 × 3 + 5 × 5
+ 4 × 8 = 63 is calculated as a subtotal of the number of FPs for the input file. Similarly, the subtotal of the number of FPs is calculated for each of the eight types of function items, and the total number of FPs is obtained as the sum of these subtotals. Further, the estimated number-of-steps calculating section 6 of the control device 2 receives, from the input device 1, information indicating the type of a tool (“C language”, “Java language”, etc.) used for development as factor information, When is used, actual information indicating how many processes were required as past results is searched from the factor database 4,
Based on the retrieved performance information, the number of FPs is converted into the number of estimated steps using a preset mathematical expression, and output to the display device 3 for display.

Here, when the number of estimated steps obtained by the conversion is too large, for example, when the order amount becomes larger than the requested one, the number of the function items that can be reduced is reduced by the operator in order to suppress the order amount. Selects by visual inspection, rewrites the specification, and repeats from the input of the number of function items.

As an example of an estimating apparatus using the FP method, a technique for calculating an estimate based on past results according to information of tools and developers is disclosed in Japanese Patent Application Laid-Open No. 9-198441, "Estimating Apparatus". And estimation methods ”. Also, a technique for recalculating the estimate according to the progress is disclosed in
-202773, "Software Project Progress Management Apparatus".

[0011]

However, in the above-described conventional estimation support system, the estimated process number calculation unit that converts the number of FPs into the estimated process number uses only limited types of factor information. There is a problem in that the number of estimation steps cannot be calculated according to specific circumstances, and the accuracy of estimation cannot be increased.

Further, in the above-mentioned conventional estimation support system,
Since a formula for converting the number of FPs to the estimated number of processes is theoretically assumed and predetermined, even if the actual information is input, a flexible approximation according to the actual information only by changing the parameters of the mathematical formula. Therefore, there was a problem that the accuracy of the estimation could not be improved.

Further, in the conventional estimation support system described above, when reconfiguring specifications, an operator looks at the specification information, selects an item to be reduced, and prepares a specification again.
There was a problem that it was necessary to input again and it was not possible to obtain an estimate efficiently.

SUMMARY OF THE INVENTION The present invention has been made to solve the above-described problems, and has as its object to provide an estimation support system and a recording medium capable of efficiently obtaining an estimation with high accuracy.

[0015]

In a software development cost estimation support system according to the present invention, a software function based on past development results under specific conditions is added to factor information indicating conditions for software development. A factor database that associates the quantity and the number of processes in a set and stores the result information as information, and a software function amount calculation unit that receives input of specification information and calculates a software function amount based on the specification information, A software development cost estimation support system, comprising: an estimation step number calculation unit that calculates an estimation step number as a result of the estimation based on the software function amount using performance information stored in the factor database. At least one set of performance information stored in the factor database in association with the same factor information. There is generated, includes the relationship approximate expression database which stores in association with the factor information relationships approximate expression representing the estimated number of steps for the software functional quantity,
The estimation process number calculation unit receives an input of software development conditions at the time of estimation creation, searches the relation approximation expression database for a relation approximation expression associated with the factor information matching the conditions, and The method is characterized in that an estimated number of steps corresponding to the calculated software function amount is calculated based on a relation approximation formula.

Further, in the software development cost estimation support system according to the present invention, upon completion of the software, the input of factor information, the amount of software functions, and the actual number of processes is performed. The set of software function amounts and the actual number of steps are stored as a set in the factor database in association with the factor information, and factor information matching the input factor information is searched from the factor database. And a database update unit that generates a relational approximation formula from the stored performance information and stores the relation approximation formula in the relation approximation formula database in association with the input factor information.

Further, in the software development cost estimation support system according to the present invention, the database updating unit searches the relational approximate expression database for a relational approximate expression corresponding to specific factor information according to an instruction. Plots and outputs the relational approximation formula
Receiving an input of an instruction to modify the plotted relational approximation formula, the plotted relational approximation formula is modified and overwritten and stored in the relational approximation formula database.

Further, in the software development cost estimation support system according to the present invention, the software function amount and the number of processes in the past development results under specific conditions are added to the factor information indicating the conditions for software development. A factor database that is stored as performance information, a software function amount calculation unit that calculates a software function amount based on input specification information, and performance information stored in the factor database. A software development cost estimation support system comprising: an estimation process number calculation unit for calculating an estimation process number as a result of the estimation based on the software function amount. The conditions for development of the software are stored, and the calculation unit for the estimated number of processes receives the input of the conditions for software development. A result information search unit that searches the factor database for the result information whose condition matches the condition indicated in the factor information, and obtains at least one set of result information, based on the acquired set of result information. Approximation formula means for generating a relation approximation formula, and calculating the estimated number of steps corresponding to the calculated software function quantity based on the generated relation approximation formula. is there.

Further, the software development cost estimating support system according to the present invention is characterized in that it has a common support unit for listing and displaying the function items whose input specification information matches. It is.

Further, in the software development cost estimation support system according to the present invention, among the function items enumerated and displayed and output by the common support unit, designation of a function item to be deleted is performed from the input unit. In response, the item is deleted and output as new specification information to the software function amount calculation unit.

Further, in a computer-readable recording medium for storing a software development cost estimation support program according to the present invention, the past development under specific conditions is compared with the factor information indicating the conditions of software development. A software function that calculates the amount of software functions based on the specification information based on the input of specification information and the factor database that stores the software function amounts and the number of processes in the results as a set and correlates the results. A software development comprising: an amount calculation step; and an estimated step number calculation step of calculating an estimated step number as a result of the estimation based on the software function amount using the performance information stored in the factor database. In a computer-readable recording medium storing a cost estimation support program, A relational approximation formula that is based on at least one set of performance information and that represents the estimated number of steps for the software function quantity, which is stored in the factor database in association with the same factor information, corresponds to the factor information. A relational approximation formula database for storing the relational approximation formula database, wherein the step of calculating the number of estimated steps receives an input of a condition for software development at the time of making the estimate, and is associated with the factor information matching the condition. Is retrieved from the factor database, and the estimated number of steps corresponding to the calculated software function amount is calculated based on the relational approximation formula.

[0022]

DESCRIPTION OF THE PREFERRED EMBODIMENTS Preferred embodiments of the present invention will be described with reference to the drawings.

Embodiment 1 FIG. 1 is a configuration block diagram of an estimation support system according to a preferred embodiment 1 of the present invention. As shown in FIG. 1, the estimation support system according to the preferred embodiment 1 of the present invention
And a display device 9, and a database 10 having a factor database 14 and a relational approximate expression database 15. Further, the control device 8 includes an FP as a software function amount calculation unit of the present invention.
It includes a number calculation unit 11, an estimated process number calculation unit 12, and a commonization support unit 13.

As shown in FIG. 2A, the factor database 14 sets the number of FPs and the number of processes in past development results for each factor flag (A) as factor information including a plurality of conditions. As shown in FIG. 2B, the relational approximate expression database 15 is calculated in advance from the corresponding result information for each factor flag (C) as the factor information, as shown in FIG. (D) is stored. Here, the number of FPs corresponds to the software function amount of the present invention. In addition, the number of steps is described as “man-hours”. FIG. 2 is an explanatory diagram showing the contents of the database 10 according to the first embodiment of the present invention. In FIG. 2B,
Although the one corresponding to the ID number of the relational approximation expression is stored for each factor information, the parameter itself of the relational approximation expression may be stored.

The plurality of conditions of the factor information include, in addition to the language used for development (“C language”, “Java language”, etc.) and its version information, for example, information on the application field of the development software. , Development experience, business knowledge, software scale, etc. It is not always necessary to specify all the conditions of the factor information, and they may be specified by selectively combining the conditions. The reason why various types of conditions are arbitrarily combined and used as the factor information is to improve the accuracy of estimation. In order to facilitate the search, it is preferable to express each condition of the factor information as a 1-bit factor flag. The relational approximation formula is a mathematical expression obtained by performing interpolation and extrapolation based on the performance information. Here, a known method is used as a method of interpolation / extrapolation.

The operation of the first embodiment of the present invention will be described below at the time of making an estimate and at the time of ending the development of software. First, the operation at the time of estimation generation will be described.

The control device 8 performs a process as shown in FIG. 3 as a process for calculating the estimated number of processes. FIG. 3 is a flowchart illustrating a process of calculating the number of estimated steps of the control device 8, and FIG. 4 is an explanatory diagram illustrating input items to the estimation support system according to the first embodiment of the present invention. As shown in FIG. 3, the control device 8 receives the input file, the output file, and the input / output , The input display item, the output display item, the input / output display item, the menu display item, the name of each function item of the form, the number of the function items, and the processing difficulty are input (S1). Hereinafter, this input item is referred to as a “survey form”. Specifically, in FIG.
For each processing, for example, in the processing of “screen”, the processing of “format information screen” to “screen 7” is performed as the name of the function item, and in the processing of the format information screen, the number of items is “normal”, and processing is difficult. This indicates that a menu display item whose degree is “normal” is displayed.

Based on the complexity matrix, the control device 8 sets the complexity of each function item to “simple”,
Evaluation is made in three levels of “normal” and “complex” (S2). For example, in the processing of the “format information screen”, since the number of items is “normal” and the difficulty of the processing is “normal”, the complexity is “normal” from the complexity matrix shown in FIG. Is evaluated. The FP number calculation unit 11 of the control device 8
Counts the number of each function item for each complexity (S
3). Specifically, in FIG. 3, the number of input files (FI) whose complexity is “simple” is counted as “2”. The FP number calculation unit 11 of the control device 8 multiplies the numerical value counted in this way by the corresponding FP number conversion value set in the FP number calculation table, further calculates the sum thereof, and The number of FPs is calculated (S4). Specifically, when the number of simple input files is “2”, the number of ordinary input files is “5”, and the number of complex input files is “4” according to the complexity, FIG. As shown in the FP number calculation table in b), the FP number conversion value for a simple input file is “3”, the FP number conversion value for an ordinary input file is “5”, and the FP number conversion value for a complex input file is “5”. Since it is “8”, 2 × 3 + 5 × 5
+ 4 × 8 = 63 is calculated as a subtotal of the number of FPs for the input file. Similarly, the subtotal of the number of FPs is calculated for each of the eight types of function items, and the total number of FPs is obtained as the sum of these subtotals. Estimated number-of-processes calculation unit 1 of control device 8
Reference numeral 2 denotes information indicating the type of a tool ("C language", "Java language", etc.) to be used for development from the input device 7, and information indicating presence / absence of development experience, business knowledge, scale, etc. Receiving as the factor information, a relation approximation formula corresponding to the factor information is searched from the relation approximation formula database 15 (S
5), the estimated number of processes is calculated by applying the total number of FPs to the relational approximation formula (S6), and the process ends.

When the estimated number of processes calculated in the process S6 is too large, for example, when the order amount becomes larger than the requested one, the user activates the common support unit 13 of the control device 8. Commonization support unit 13 of control device 8
Performs a process as shown in FIG. FIG. 5 is a flowchart illustrating the process of the sharing support performed by the sharing support unit 13. The common support unit 13 searches for a function item having the same name or the same type (for example, “input file”) for each of the function items input as the survey form (S11). If there is such a plurality of function items (if Yes), it is added to the commonization candidate table as shown in FIG. 6 (S12), and the process proceeds to S13. In addition, if such a function item is not searched in the process S11 (if No), it is checked whether or not the search for all the function items has been completed (S13), and if the search has been completed (Yes). If so, the process proceeds to step S14, and if not completed (if No), the process returns to step S11 to continue the process. FIG. 6 is an explanatory diagram illustrating an example of the commonization candidate table.

When the search is completed and the generation of the common candidate table is completed, the common support unit 13 displays the common candidate table on the display device 9 (S14). The common support unit 13 also waits for an instruction from the user (S15), and checks whether the input instruction is a designation to delete a part of the function item displayed in the processing S14 (S1).
6) If the instruction is a deletion instruction (Yes), the designated function item is deleted from the commonization candidate table (S
17) Then, the process returns to step S15 to wait for an instruction. If the instruction is not an instruction to delete in step S16 (if No), it is checked whether the instruction is an end instruction (S1).
8) If not an end instruction (if No), process S
15 and waits for an instruction.
If s), the survey form is re-created according to the commonization candidate table (S19), and the process ends. Then, the control device 8 performs the estimation process shown in FIG. 3, calculates the number of FPs again based on the reconstructed questionnaire, and further calculates the estimated number of processes.

Next, processing at the end of software development according to the present embodiment will be described. FIG. 7 is a flowchart illustrating processing at the end of software development according to the present embodiment.

When the development of the software is completed, the control device 8 transmits, from the input device 7, the factor information as the development conditions of the software whose development has been completed, the actual number of FPs, and the actual number of processes. In response to the input (S21), a set of performance information corresponding to the input factor information is searched and extracted from the factor database 14 (S22), and the performance information and the actual information newly input in the process S21 are retrieved. The actual number of processes with respect to the number of FPs is output as a scatter diagram on the display device 9 (S23), and the data displayed in the scatter diagram is interpolated / extrapolated by a known interpolation / extrapolation method to obtain a relational approximate expression Is generated (S24), and displayed on the display device 9 together with the approximate relational expression.

When the user thinks that the relational approximation expression displayed and displayed on the display device 9 does not match the actual situation, the user modifies the relational approximation expression here. In particular,
A part of the graph of the relational approximation equation displayed on the display device 9 is dragged to adjust the interpolation / extrapolation parameters. The control device 8 determines whether or not a correction input of the relational approximation formula has been received (S25). If the correction input has been received (Yes), the control device 8 returns to the process S24 and returns to the interpolation / extrapolation parameters. Is adjusted to recalculate the relational approximation formula, and the result is output to the display device 9 again. In step S25, if no correction input has been received (if No), it is determined whether an instruction to end the processing has been input (S26). If an instruction to end the processing has not been received, (If No), process S2
5, the process is continued, and if an instruction to end the process has been received (Yes), the current relationship approximate expression corresponding to the factor information input in process S21 is searched from the relationship approximate expression database 15. Then, the relation approximation formula generated in step S24 is overwritten on the relation approximation formula and stored (S27), and the process ends.

According to the present embodiment, a plurality of conditions can be treated as factor information, and the number of estimated steps is calculated using a relational approximation formula generated in advance based on past performance information. The accuracy of the estimate can be improved. Further, at the end of the development, the relational approximation formula is readjusted again based on the actual number of FPs and the number of processes of the newly developed software, so that the accuracy of estimation from next time can be improved.

Further, according to the present embodiment, by the function of the common support unit 13, the duplicated functions can be presented, and the specification can be reconfigured based on the instructions. Can be.

Embodiment 2 In the first embodiment,
For each piece of factor information, a relational approximation formula was generated and stored in advance, but when calculating the estimated number of processes, a relational approximation formula was searched and generated based on the factor information, and the generated relation approximation formula was generated. It is also preferable to use Therefore, a software development cost estimation support system according to the second embodiment of the present invention that generates a relational approximation formula when calculating the estimated number of processes will be described below.

The estimation support system according to the present embodiment will be described below with reference to the drawings. Note that parts having the same configuration as that of the estimation support system according to the first embodiment shown in FIG. FIG. 8 is a configuration block diagram of an estimation support system according to a preferred embodiment 2 of the present invention. As shown in FIG. 8, it mainly comprises an input device 7, a control device 16, a display device 9, and a database 17. Here, the control device 16 includes the FP number calculation unit 11 and the estimated process number calculation unit 12
And a commonization support unit 13. Database 1
7 includes a factor database 14. The contents of the factor database 14 are the same as those according to the first embodiment of the present invention shown in FIG.

The operation of the second embodiment of the present invention will be described below at the time of making an estimate and at the time of ending the software development. First, the operation at the time of estimation generation will be described.

The control device 16 performs a process as shown in FIG. 9 as a process for calculating the estimated number of processes. FIG. 9 is a flowchart illustrating a process performed by the control device 16 to calculate the estimated number of processes. As shown in FIG. 9, the control device 16 receives the input file, the output file, and the input / output Enter the name of each function item of file, input display item, output display item, input / output display item, menu display item, form, and the number of the function items and the difficulty of processing (input of survey form). Received (S31).

Based on the complexity matrix, the control device 16 evaluates the complexity of each function item from the description of the questionnaire in three stages of "simple", "normal", and "complex" (S3).
2) The FP number calculation unit 11 counts the number of each function item for each complexity (S33). FP number calculation unit 11
Is the numerical value for each function item counted in the processing S33, and the corresponding F set in the FP number calculation table.
The total number of FPs is calculated by multiplying the converted P number and further calculating the sum thereof (S34). Also, the control device 16
The estimation process number calculation unit 12 receives the input of the factor information from the input device 7, acquires the performance information stored corresponding to the factor information (S35), and based on the acquired performance information. By a known interpolation / extrapolation method, a relational approximate expression is generated as a mathematical expression representing the number of estimated steps with respect to the number of FPs (S36). Then, the control device 16 adds the total FP calculated in step S34 to the relation approximate expression generated in step S36.
The estimated number of steps is calculated by applying the numbers, and the calculated number is output to the display device 9 (S37), and the process is terminated.

When the estimated number of processes calculated in the process S37 is too large, for example, the order amount becomes larger than the requested one, a common process as shown in FIG. The operations performed are the same as those performed by the estimation support system according to the first embodiment of the present invention, and a description thereof will be omitted.

Next, processing at the end of software development according to the present embodiment will be described. FIG. 10 is a flowchart illustrating processing at the end of software development according to the present embodiment.

When the development of the software is completed, the control device 16 uses the input device 7 to transmit the factor information as the conditions for the development of the developed software, the actual number of FPs, and the actual number of processes. Upon receiving the input (S41), the input number of FPs and the actual number of steps are combined into a set, stored in the factor database 14 in association with the input factor information (S42), and the process is terminated.

According to the present embodiment, a plurality of conditions can be treated as factor information, and a relational approximation formula is generated based on past performance information, and the estimated number of processes is calculated using this formula. The accuracy of the estimate can be improved. Also,
At the end of the development, the performance information is accumulated based on the actual number of FPs and the number of processes of the software that has been newly developed, so that the accuracy of estimation from the next time can be improved.

Further, according to the present embodiment, by the function of the common support unit 13, the duplicated function can be presented and the specification can be reconstructed based on the instruction, so that the estimate can be created efficiently. Can be.

In the first and second embodiments, a case has been described in which the number of steps is estimated. However, instead of the number of steps, the number of software test items and the error By accumulating the number of detections and the like as performance information, it is possible to create estimates of these numerical values.

Embodiment 3 Further, the first and second embodiments can be realized as a computer program, and can be stored in a computer-readable recording medium.

[0048]

Since the present invention is configured as described above, it has the following effects.

For each past development result under the specific conditions indicated in the factor information, a relational approximation formula representing the estimated number of processes according to the software function amount is generated and accumulated. In response to the input of the information, the software function amount calculated from the specification information is calculated, and a relational approximation formula is searched under conditions that match the development conditions. Since the number of estimated steps is calculated by applying the functional quantity, it is possible to create an estimate according to various developmental conditions, and to improve the accuracy of the estimate.

When the software is completed, the input of the factor information, the amount of software functions, and the actual number of processes is received, and a relational approximation formula corresponding to the factor information is generated and updated, so that the next time the software is completed, Can improve the accuracy of the estimate.

Further, the relational approximation formula is plotted and displayed and output according to the instruction, and the relational approximation formula is corrected, overwritten and stored in response to the input of the correction instruction, so that the accuracy of estimation can be further improved. it can.

According to the fourth aspect of the present invention, a set of a software function amount and the number of processes is stored as result information in association with factor information in past development results, Receives specification information at the time of making an estimate, calculates software function quantity, searches for performance information under conditions that match development conditions, generates a relational approximation formula from the performance information, and calculates the calculated software By calculating the estimated number of processes by applying the functional quantity, it is possible to create an estimate according to various developmental conditions, and to improve the accuracy of the estimate.

Furthermore, by enumerating and displaying the function items that match the input specification information, it is possible to easily reconfigure the specification and obtain an efficient estimate.

Further, upon receiving an input of designation of a function item to be deleted from the enumerated function items, the number of estimated steps is calculated based on new specification information in which the function item is deleted, so that an efficient estimate can be obtained. Can be.

Further, such an estimation support system is realized as a computer program, and a highly accurate estimate can be obtained efficiently as a computer-readable recording medium.

[Brief description of the drawings]

FIG. 1 is a configuration block diagram of an estimation support system according to a preferred embodiment 1 of the present invention;

FIG. 2 is an explanatory diagram showing contents of a database 10 according to the first embodiment of the present invention.

FIG. 3 is a flowchart illustrating a process of calculating an estimated number of processes by the control device 8;

FIG. 4 is an explanatory diagram showing input items to an estimation support system according to the first embodiment of the present invention.

FIG. 5 is a flowchart illustrating a process of common support by the common support unit 13.

FIG. 6 is an explanatory diagram illustrating an example of a commonization candidate table.

FIG. 7 is a flowchart illustrating processing at the end of software development according to the present embodiment.

FIG. 8 is a configuration block diagram of an estimation support system according to a preferred embodiment 2 of the present invention;

FIG. 9 is a flowchart illustrating a process performed by the control device 16 to calculate an estimated number of processes.

FIG. 10 is a flowchart illustrating processing at the end of software development according to the present embodiment.

FIG. 11 is an explanatory diagram illustrating an example of a table for calculating a software function amount.

FIG. 12 is a configuration block diagram of a conventional estimation support system.

FIG. 13 is an explanatory diagram showing input items in a conventional estimation support system.

[Explanation of symbols]

1,7 input device, 2,8,16 control device, 3,9
Display device, 4,14 factor database, 5,11 FP
Number calculation unit, 6,12 Estimated process number calculation unit, 10,17
Database, 13 common support unit, 15 relational approximation formula database.

 ────────────────────────────────────────────────── ─── Continuing on the front page (72) Inventor Toshikazu Yamazaki 2-3-2 Marunouchi, Chiyoda-ku, Tokyo F-term in Mitsubishi Electric Corporation 5B046 JA01 KA05 5B049 BB07 CC11 CC21 DD00 EE03 EE05 FF03 FF04 5B076 EC09

Claims (7)

[Claims] 1. A factor database which stores a set of software function amounts and the number of processes in past development results under specific conditions in association with factor information representing conditions in software development and stores the results as performance information. A software function amount calculating unit that receives input of specification information and calculates a software function amount based on the specification information; and using the performance information stored in the factor database, the software function amount A software development cost estimation support system comprising an estimated process number calculation unit for calculating an estimated process number as a result of the estimation based on the factor database stored in the factor database in association with the same factor information. , A relational approximation expression that is generated based on at least one set of performance information and that represents the A relational approximation formula database that is stored in association with the information, and the estimation process number calculation unit receives an input of a condition for software development at the time of estimation creation, and is associated with the factor information that matches the condition. Searching the relational approximation formula from the relational approximation formula database,
A software development cost estimation support system, wherein an estimated number of steps corresponding to the calculated software function amount is calculated based on the relation approximation formula. 2. When the software is completed, factor information and
Receiving the input of the software function amount and the actual number of steps, storing the input software function amount and the actual number of steps in the factor database in association with the factor information, Retrieving factor information matching the input factor information from the factor database, generating a relational approximation from the correspondingly stored actual information, and associating with the input factor information, 2. The software development cost estimation support system according to claim 1, further comprising a database updating unit that stores the approximate expression database. 3. A database update unit searches for a relational approximation expression corresponding to specific factor information from the relational approximation expression database according to an instruction, plots and outputs the retrieved relational approximation expression, and displays the plotted relational expression. 3. The software development cost according to claim 2, wherein upon receiving an instruction to modify the relational approximation formula, the plotted relational approximation formula is modified and overwritten and stored in the relational approximation formula database. Estimation support system. 4. A factor database that stores a set of software function amounts and the number of processes in a past development result under specific conditions in association with factor information representing a condition in software development and stores the result as performance information. And a software function amount calculation unit that calculates a software function amount based on the input specification information, and a result of the estimation based on the software function amount using actual information stored in the factor database. A software development cost estimating support system comprising: an estimated process number calculating unit that calculates an estimated process number as the above; wherein the factor database stores a plurality of development conditions as factor information; However, upon receiving a condition for software development, the result data in which the condition matches the condition indicated in the factor information is stored in the factor data. A performance information search means for searching from a base and acquiring at least one set of performance information; and an approximate expression means for generating a relational approximate expression based on the acquired set of performance information. A software development cost estimation support system, wherein an estimated number of steps corresponding to the calculated software function amount is calculated based on the relational approximation formula. 5. A common support unit for enumerating and displaying function items whose input specification information coincides with each other, and outputting the same. Software development cost estimation support system. 6. A function item to be deleted, among the function items enumerated and displayed and output by the common support unit, is received from the input unit, the item is deleted, and the item is deleted as new specification information. 6. The estimation support system according to claim 5, wherein the output is outputted to a software function amount calculation unit. 7. A factor database that stores a set of software function amounts and the number of processes in a past development result under specific conditions and associates them with factor information representing conditions in software development. Receiving the input of the specification information, calculating the software function amount based on the specification information, and using the performance information stored in the factor database to calculate the software function amount. A computer-readable recording medium storing a software development cost estimation support program, comprising: an estimation process number calculation step of calculating an estimation process number as a result of the estimation based on the same factor information in the factor database. Generated based on at least one set of performance information stored in association with the A relational approximation formula database that stores a relational approximation formula representing the estimated number of processes for the software function amount in association with the factor information, wherein the step of calculating the number of estimated processes receives an input of a condition for software development at the time of creating the estimate. Searching for a relational approximation formula associated with the factor information matching the condition from the factor database, and calculating an estimated number of steps corresponding to the calculated software function amount based on the relational approximation formula. A computer-readable recording medium characterized by the following.