JP2001282525A - Coding quantity measuring instrument and method, and recording medium - Google Patents

Abstract

PROBLEM TO BE SOLVED: To provide a coding quantity measuring instrument capable of easily grasping a change of workload due to a change of workload in each contents such as addition, deletion and change executed by a programmer and a change of structure. SOLUTION: This instrument is provided with a 1st means for retrieving a source file, storing source codes in a source code storage file and storing source structure in a source structure storage file, a 2nd means for reading out the source file stored in the source code storage file and measuring the amount of source codes and a changed amount and a 3rd means for reading out the source structure from the source structure storage file and measuring the quantity of the source structure and its changed quantity.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to software development, and more particularly to a method and apparatus for measuring the amount of coding used for managing the progress of software development work using object-oriented technology.

[0002]

2. Description of the Related Art Conventionally, when measuring the amount of coding to grasp the progress of software development work, only the number of step lines and comment lines of a program are measured, and only the scale and size of the program are grasped. Was.

[0003]

However, in the prior art, as used in the object-oriented development process, addition, deletion, change, etc. of source code that occur in the case of iterative development or enhancement work of an existing program are performed. Can not be measured, the addition by the programmer,
There is a problem that the amount of work for each content such as deletion and change cannot be grasped. Another problem is that it is not possible to determine whether the work performed by the programmer is a change in the class structure, a change in the interface, or a change in the internal algorithm.

[0004] It is an object of the present invention to add by a programmer,
It is an object of the present invention to provide a coding amount measuring method and apparatus capable of easily grasping a change in the amount of work for each content such as deletion and change and a change in the amount of work due to a change in the structure.

[0005]

In order to achieve the above object, the present invention provides a first method for searching a source file, storing a source code in a source code storage file, and storing a source structure in the source structure storage file. Means for reading the source file in the source code storage file, and measuring the amount of source code and the amount of change, reading the source structure in the source structure storage file, and And third means for measuring the amount.

The data measured by the second and third means is written to a progress management data file,
A fourth means for displaying daily measurement data as a graph and a fifth means for writing the measured data to a project data file and displaying the measurement data in the repetition as a graph are further provided.

A first step of searching for a source file, storing the source code in the source code storage file, and storing the source structure in the source structure storage file, and reading the source file in the source code storage file; The second to measure the amount of source code and the amount of change
And a third step of reading the source structure in the source structure storage file and measuring the amount of source structure and the amount of change.

[0008]

DESCRIPTION OF THE PREFERRED EMBODIMENTS One embodiment of the present invention will be described below in detail with reference to the drawings. FIG. 1 is a block diagram showing an embodiment of a coding amount measuring apparatus according to the present invention. The coding amount measuring apparatus according to the present embodiment includes a central processing unit 101 that performs input and output for measuring a coding amount, a keyboard device 102 that performs input and output with a user, a display device 103, and a list of source file names. Makefile 104 of the compiler storing the source file 105 and the source file 105 to be measured
And a source code storage file 114 storing source codes created in daily work, and a class structure storage file 11 storing daily source structures (here, class structures in object-oriented programs).
5, a progress management data file 116 storing measurement data necessary to draw a graph for daily progress management, and a graph for each position and iteration of a makefile for coding amount measurement. It is provided with a project data file 117 storing measurement data necessary for drawing.

The central processing unit 101 has a progress measuring process 1
06, a repetition change amount measurement process 107, a source code accumulation process 108, and a coding amount measurement process 109. A source code storage process 108 and a coding amount measurement process 109 are implemented. The coding amount measuring process 109 functions as a subroutine of the progress measuring process 106 and the iterative change amount measuring process 107.

A coding amount measuring process 109 measures a source code amount measuring process 110 for measuring the number of step lines, comment lines, and the number of files, and counts additions, deletions, and changes of the number of step lines and comment lines. Source code change amount measurement processing 111 and class structure measurement processing 1 for measuring the number of classes, the number of methods, and the number of lines of methods
12 and a class structure change amount measurement process 113 for counting the number of additions, deletions, and changes of the number of classes, the number of methods, and the number of lines of methods.

FIG. 2 shows a source code storage file 114.
This is an example. The source code storage file 114 includes source code information 201 for each date. The source code information 201 for each date is the date 2 when the measurement was performed.
02, the name of the source file 203 to be measured,
It consists of the contents 204 of the source file. In the contents 204 of the source file, the first character has an identifier 205 for identifying whether it is a step line or a comment line. As a result, the source file can be measured separately from the step line and the comment line.

FIG. 3 shows an example of the class structure storage file 115. The class structure storage file 115 includes class information 301 for each date. The class information 301 for each date includes a date 302 at which the measurement was performed, and a class name 303, a method name 304, and a method content 305 extracted from the source file 105.

FIG. 4 shows a progress management data file 116.
This is an example. The progress management data file 116 includes the date 402 at which the measurement was performed, the number of step lines, the number of comment lines, the number of files, the number of classes, the number of methods, and the numerical value 403 of methods, an additional amount 404, It consists of a deletion amount 405 and a change amount 406.

FIG. 5 shows the project data file 11
7 is an example. The project data file 117 is
It consists of a project name 501, a position 502 of the makefile 104, and information 503 for each iteration. The information 503 for each iteration includes the start date 504 of the iteration, the end date 505 of the iteration, the number of step lines and the number of comment lines, the number of files, the number of classes, the number of methods, the number of method lines, and the amount of addition. , Deletion amount, and change amount.

FIG. 6 is a flowchart showing the processing contents of the progress measurement processing 106. 6, first, the source file 105 to be measured is read, the source code is stored in the source code storage file 114, and the source code storage processing 108 for storing the class structure in the class structure storage file 115 is performed (step 601). , The comparison-destination date necessary for measuring the amount of change is set to the latest date (step 602), the comparison-source date is set immediately before the latest date (step 603), and the coding amount measurement process is performed. Step 109 is performed (step 604), and the obtained numerical value is displayed on a graph (step 605).

FIG. 7 is a flowchart showing the processing contents of the repetitive change amount measurement processing 107. In FIG. 7, first, the comparison destination date necessary for measuring the amount of change is set to the latest date (step 701), and the comparison source date is set to the latest iteration start date (step 702). The coding amount measurement processing 109 is performed (step 703), and the obtained numerical value is displayed on a graph (step 704).

FIG. 8 is a flowchart showing the processing of the source code storage processing 108. In FIG. 8, first,
The make file is searched from the position 502 of the make file stored in the project data file 117 and opened (step 801). A list of source file names described in the make file is obtained (step 802), and a loop is started for the obtained source file (step 803). By obtaining the source file name from the makefile used by the compiler,
The source file to be measured has been devised so that there is no omission. In the loop, the source file is first opened, and the source file is read line by line, and it is determined whether it is a step line or a comment line (step 804). The content of the source file is stored in the source code storage file 114 with the determination flag 205 of step line or comment line attached (step 805). Further, the source code is analyzed (step 806), and if there is a class, the class name, the method name and the contents of the method are stored in the class structure accumulation file 114 (step 807). This is performed for all the source files acquired in step 802 (step 808).

FIG. 9 is a flowchart showing the coding amount measuring process 109. In FIG. 9, first, a source code amount measurement process 110 for the latest date
(Step 901), and the source code change amount measurement processing 111 is performed on the set comparison source and comparison destination (step 902). Thereafter, the class structure measurement processing 112 is performed on the latest date (step 903), and the class structure change amount measurement processing 1 is performed on the set comparison source and comparison destination.
13 is performed (step 904). It is determined whether the caller of the coding amount measuring process 109 is the progress measuring process 106 or the iterative change amount measuring process 107 (step 9).
06) If it is a progress measurement, the measured data is stored in the progress data file 116 (step 906); otherwise, the measured data is stored in the project data file 117 (step 907).

FIG. 10 shows a source code amount measuring process 110.
6 is a flowchart showing the processing of FIG. In FIG. 9, first, the source code storage file 114 is opened (step 1001), and a loop is started for all the files stored on the latest date (step 1002). Identifier 205 for step line or comment line
And the number is measured (step 1003, step 1004). This is repeated until the end of the file is reached (step 1005). The measured number of step lines, the number of comment lines, and the number of files are stored (step 100).
6).

FIG. 11 shows source code change amount measurement processing 1
11 is a flowchart showing the process of FIG. In FIG. 11, first, the source code storage file 114 is opened (step 1101), and a loop is started for all files on the set comparison destination date (step 1102). At the date of the comparison source, it is determined whether or not a file name identical to the file name of the comparison destination exists (step 1103). If the file name exists, the difference between the comparison destination and the comparison source is obtained (step 1104). The numerical values of the added amount of the step line, the deleted amount of the step line, the changed amount of the step line, the added amount of the comment line, the deleted amount of the comment line, and the changed amount of the comment line are increased from the current values as the measurement data (step 1105). ). If the same file name does not exist in the comparison source, the number of each line of the comparison destination is added to the current value as the addition amount of the step line and the addition amount of the comment line (step 1106). This is repeated until the comparison destination file ends (step 1107). Next, a loop is started for all files on the comparison source date (step 1108). It is determined whether a file name identical to the file name of the comparison source does not exist on the date of the comparison destination (step 1109). If not, the number of step lines and the number of comment lines of the comparison source are determined by the step of the measurement data. The deletion amount of the line and the deletion amount of the comment line are respectively added (step 1110). This is repeated until all files of the comparison source end (step 11).
11).

FIG. 12 is a flowchart showing the class structure measuring process 112. In FIG. 12, first, the class structure accumulation file 114 is opened (step 1201), and a loop is started for all classes on the latest date (step 1202). The number of methods in the class and the number of lines of the method are measured and added (step 1203, step 1204), and this is repeated until the class with the latest date ends (step 120).
5). The number of classes, the number of methods, and the number of method lines are set as measurement data (step 1206).

FIGS. 13 and 14 are flowcharts showing the class structure change amount measuring process 113. 13 and 14, first, the class structure accumulation file 114 is opened (step 1301), and a loop is started for all classes on the set comparison destination date (step 1302). At the date of the comparison source, it is determined whether or not a class name identical to the class name of the comparison destination exists (step 1303). If the class name exists, the class change flag is initialized to No (step 1304). (Step 1305). It is determined whether the same method name exists in the comparison source class (step 13).
06) If there is, the difference between the contents of the method is acquired (step 1307). If there is a difference, the amount of addition of the number of method lines, the amount of deletion of the number of method lines, and the amount of change in the number of method lines of the measurement data are added, and the amount of change in the number of methods is increased by one (step 1309). ).

Also, in the determination of step 1306,
If the same method does not exist, the additional amount of the number of methods in the measurement data is increased by one (step 131).
0), the class change flag is set to Yes (step 1)
311). The process returns to step 1305 until the method in the comparison destination class ends (step 131).
2).

Next, a loop is started for all methods in the comparison source class (step 131).
3). It is determined whether or not the same method name as the method name in the comparison source class exists in the comparison destination class (step 1314). If not, the numerical value of the deletion amount of the number of methods in the measurement data is set to 1 The class change flag is set to Yes (step 1316). The process returns to step 1313 until the method in the comparison source class ends (step 1317). Thereafter, it is determined whether or not the class change flag is Yes (step 1318). If Yes, the numerical value of the amount of change in the number of classes of the measurement data is increased by one (step 1319). If the same class name does not exist on the comparison source date in the determination of step 1303, the added value of the number of classes of the measurement data is set to 1
(Step 1320). The process returns to step 1302 until the class of the comparison destination ends (step 1
321).

Next, a loop is started for all classes on the comparison source date (step 1322). It is determined whether or not the same class name exists on the date of comparison (step 1323).
The numerical value of the deletion amount of the number of classes of the measurement data is increased by one (step 1324). The process returns to step 1322 until the class on the comparison source date ends (step 1325).

FIG. 15 is a diagram showing an example of an output result of the progress measuring process 106. Project data file 11
7 is the text of the project name 501 stored in
In 501, make file position 502 is text 15
02, the current iteration number in text 1503, the iteration start date in text 1504, and today's date in text 153.
05 respectively. The graph 1506 is a line graph showing the number of step lines, the number of comment lines, and the total number of lines which is the sum of the number of step lines and the number of comment lines.

Thus, it is possible to grasp how the size of the current project is changing.
A graph 1507 shows the number of files, the number of classes, the number of methods, and the number of lines of methods in a line graph. This makes it possible to grasp the scale of the current project as object-oriented. In addition, the graph 1508 is a line graph in which the added amount, the changed amount, and the deleted amount of the total number of lines, the number of step lines, and the number of comment lines are accumulated. This allows
The work load of the current project can be grasped.

A graph 1509 indicates the amount of change in the number of classes, the number of methods, and the number of method lines by a polygonal line. This makes it possible to understand whether the current project implements the class structure, the interface part, or the internal algorithm, and how long it takes to implement it later It becomes easier to consider whether or not.

FIG. 16 shows an example of the output result of the iterative change amount measuring process 107. Graph 1601 represents the number of rows for each iteration as a bar graph. Thereby, it is possible to grasp the change in the scale of the project for each iteration. Graph 160
2 represents the number of classes for each iteration by a line, and the amount of change by a bar graph. By examining the amount of change in the number of classes for each iteration, it is possible to know whether or not a modification has been made to the previous iteration, and it is possible to see the poor structural design of the previous class. The graph 1603 shows the number of methods for each iteration as a line, and the amount of change as a bar graph. By examining the amount of change in the number of methods for each iteration, it is possible to know whether or not the previous iteration has been modified, and to see the poor design of the previous interface. The graph 1604 shows the number of lines of the method for each iteration by a line, and the amount of change by a bar graph. By examining the amount of change in the number of lines in the method for each iteration, it was possible to understand what modifications were made to the previous iteration, and to add a new function to rewrite the internal algorithm. It will be a good indication of what is going on.

In the above embodiment, an example in which the present invention is applied to the measurement of the coding amount in the development work of an object-oriented program has been described. However, the present invention is limited to the measurement of the coding amount in the development work of the object-oriented program. is not.

A series of processes for measuring the coding amount can be recorded on a recording medium such as a CD-ROM and provided to a software developer so that the program can be executed by a general-purpose computer.

[0032]

As described above, according to the present invention, the work amount (or scale) and its change for each content such as addition, deletion, and change by the programmer, and the work amount and the change amount for the change in the structure. Changes can be easily grasped. In particular, by graphing the amount of change, the amount of work and the progress of the project can be presented in an easily understandable manner, thereby contributing to the management of the progress.

Further, by graphing the amount of change in iteration, it is possible to easily grasp whether the class structure, interface, or internal algorithm has been changed, and the software development work can be easily understood. An extremely useful effect can be obtained in grasping the progress.

[Brief description of the drawings]

FIG. 1 is a block diagram showing an embodiment of a coding amount measuring device according to the present invention.

FIG. 2 is a diagram illustrating an example of a source code storage file.

FIG. 3 is a diagram showing an example of a class structure accumulation file.

FIG. 4 is a diagram showing an example of a progress management data file.

FIG. 5 is a diagram showing an example of a project data file.

FIG. 6 is a flowchart of a progress measurement process.

FIG. 7 is a flowchart of an iterative change amount measurement process.

FIG. 8 is a flowchart of a source code accumulation process.

FIG. 9 is a flowchart of a coding amount measurement process.

FIG. 10 is a flowchart of a source code amount measurement process.

FIG. 11 is a flowchart of a source code change amount measurement process.

FIG. 12 is a flowchart of a class structure measurement process.

FIG. 13 is a flowchart of a class structure change amount measurement process.

FIG. 14 is a flowchart showing a continuation of FIG. 13;

FIG. 15 is a diagram illustrating an example of an output screen of a progress measurement process.

FIG. 16 is a diagram illustrating an example of an output screen of a repeated change amount measurement process.

[Explanation of symbols]

101: central processing unit, 102: keyboard device, 10
3 ... display device, 104 ... makefile, 10
5 Source file, 106 Progress measurement processing, 107
Iterative change amount measurement processing, 109: coding amount measurement processing, 114: source code accumulation file, 115: class structure accumulation file.

Claims (4)

[Claims] An apparatus used for progress management in software development work, comprising: first means for searching for a source file, storing source code in a source code storage file, and storing a source structure in the source structure storage file; A second means for reading the source file in the source code storage file and measuring the amount and the change amount of the source code; and reading the source structure in the source structure storage file and measuring the amount and the change amount of the source structure And a third means for measuring the amount of coding. 2. A fourth means for writing data measured by the second and third means to a data file for progress management and displaying daily measured data in a graph, and a means for storing measured data in a project data file. 5. A coding amount measuring apparatus according to claim 1, further comprising: a fifth means for writing and displaying the measured data in the repetition as a graph. 3. A method for managing progress in software development work, comprising: searching for a source file, storing source code in a source code storage file, and storing a source structure in the source structure storage file; Reading a source file in the source code storage file and measuring the amount and change amount of the source code; and reading a source structure in the source structure storage file and measuring the source structure amount and change amount. And a third step of measuring the coding amount. 4. A medium storing a program for measuring a coding amount in software development work, wherein a source file is searched, a source code is stored in a source code storage file, and a source structure is stored in the source structure storage file. A first process, reading a source file in the source code storage file, and measuring a source code amount and a change amount; a second process, reading a source structure in the source structure storage file; A recording medium characterized by recording a computer-readable program including: and a third process for measuring a change amount.