JP2011258076A - Java source code check program - Google Patents

Abstract

PROBLEM TO BE SOLVED: To provide a quality check program capable of recognizing a tendency for each programmer with respect to an item which has an impact on quality of Java source code.SOLUTION: A Java source code check program according to the present invention extracts a programmer name from a tag part in which the programmer name of a Java class described in the Java source code is described, and totalizes the number of creation steps per a class for each programmer.

Description

  The present invention relates to a program for checking the quality of a program source code written in Java (registered trademark) language.

  Software development always requires high-quality deliverables, and various inspection activities are being conducted to improve quality. Since the development period is limited, it is necessary to conduct quality inspections quickly and with high accuracy.

  Looking at the quality check of the source code that is the product of the downstream development process, there are two main methods: a test and a visual check. Of these, the specifications required for the software are confirmed during the test, and the quality such as malfunction, inefficiency description, maintainability, etc. that are difficult to find in the test is confirmed in addition to the specification confirmation by visual inspection. Visual inspection to confirm such a large amount of content is important as an activity for ensuring quality, but it involves the problem that it tends to be overlooked even though it takes time, and it is personal and varies in accuracy.

  In recent years, in open languages such as Java, tools such as FindBugs (Non-Patent Document 1) and Checkstyle (Non-Patent Document 2) have emerged as tools that support visual inspection, and are used in various projects.

URL: http://findbugs.sourceforge.net/ URL: http://checkstyle.sourceforge.net/

  In the technologies described in Non-Patent Documents 1 and 2, a bug in the Java source code is automatically detected based on a detection rule set in advance, or whether the description style of the Java source code conforms to the rule. Can be determined.

  However, in software development projects, it can be said that the development of bugs and the description style of the source code tend to reflect the unique trends of each developer. Such personal tendency has not been recognized much by conventional quality check tools.

  The present invention has been made in order to solve the above-described problems, and provides a quality check program capable of grasping the tendency of each program creator with respect to matters affecting the quality of Java source code. For the purpose.

  The Java source code check program according to the present invention extracts the creator name from the tag portion describing the creator name of the Java class described in the Java source code, and the number of creation steps per class for each creator Are counted.

  According to the Java source code check program of the present invention, it is possible to grasp the tendency of the number of steps per class of each program creator. A large number of steps per class means that a large class is created, which is not preferable from the viewpoint of maintainability of source code. According to the Java source code check program according to the present invention, it is possible to identify a creator having such a tendency and appropriately take measures such as prompting improvement.

It is a figure which shows the input / output of the computer 100 which executes the Java source code check program 110 which concerns on Embodiment 1, and related data. A sample Java source code 200 is shown. A sample Java source code 200 is shown.

<Embodiment 1>
FIG. 1 is a diagram showing a computer 100 that executes a Java source code check program 110 according to Embodiment 1 of the present invention and related data input / output. The computer 100 is a computer used for checking a Java program.

  The computer 100 receives the Java source code 200 to be checked and the check rule data 300 defining the check rule as inputs, and outputs the check result of the Java source code 200. These data are stored in a storage device included in the computer 100 as necessary.

  The computer 100 includes a storage device such as an HDD (Hard Disk Drive) that stores the Java source code check program 110 and an arithmetic device such as a CPU (Central Processing Unit) that executes the Java source code check program 110. In addition, an interface for inputting / outputting each data, a memory, and the like are provided as appropriate. Hereinafter, for convenience of explanation, the Java source code check program 110 may be described as an operation subject. However, it is added that the Java source code check program 110 is actually executed by an arithmetic unit such as a CPU.

  The check rule data 300 defines one or more check rules that serve as a reference when the Java source code check program 110 checks the Java source code 200. A specific procedure defined by the check rule data 300 will be described again with reference to FIG.

  FIG. 2 shows a sample Java source code 200. For convenience of explanation, the line number is shown on the left side of the source code. In FIG. 2, the part enclosed by “/ *” and “* /” is a comment part. Specifically, the third to seventh lines, the 11th to 13th lines, and the 17th to 20th lines are comment portions.

Of the items described in each comment, the part beginning with “@” is a tag part that specifies that comment-specific information of the Java source code is described. The contents of each tag stipulate that the following items should be described by the Javadoc specification, which is a Java standard comment rule.
(FIG. 2: @author tag) This tag describes the creator name of the Java class.
(FIG. 2: @version tag) This tag describes a numerical value representing the release version of the Java class.
(FIG. 2: @param tag) This tag describes a method argument in the Java class.

  A comment in the Javadoc format is originally described in order to automatically generate a Java class specification. For example, a Java class specification can be automatically generated by extracting information such as methods, arguments and return types of each Java class from the Java source code main body and each tag in Javadoc.

  Due to the purpose of the Javadoc specification, Javadoc comments are generally used to describe the attributes of Java classes in comments, and therefore, the “@author” tag has only been used as auxiliary information.

  The present invention pays attention to the fact that the creator name of the Java class is embedded in the Java source code, and is intended to be used for grasping the quality trend of the Java source code for each program creator.

  As a guideline for measuring the quality tendency for each program creator, the number of steps per class can be mentioned. Generally, a Java class normally describes only a Java instruction specialized for its purpose. Therefore, the number of steps of each Java class should be within the number of steps corresponding to the purpose of the Java class. However, if a Java class is created so that one Java class corresponds to a plurality of purposes, the number of steps of the Java class is expected to increase accordingly.

  When one Java class corresponds to a plurality of purposes, it is not known which function belongs to which Java class, and the maintainability of the Java class is lowered. Such a tendency to create a Java class with low maintainability is often unique to each program creator. Therefore, in the first embodiment, the number of steps per class is totaled for each program creator, and measures such as calling a program creator who tends to create a Java class having an extremely large number of steps are called. To take.

  The Java source code check program 110 executes the above aggregation process according to the following procedure.

(Java source code check procedure: Step 1)
The Java source code check program 110 reads the Java source code 200 (source code file) from a storage device such as an HDD. A plurality of Java source codes 200 may be read together or may be read one by one.

(Java source code check procedure: Step 2)
The Java source code check program 110 identifies the comment portion of the Java source code 200 read in step 1. Specifically, the part surrounded by “/ *” and “* /” and the line starting with “//” are specified as the comment part.

(Java source code check procedure: Step 2: Supplement)
Strictly speaking, a tag of the Javadoc specification is described in a portion surrounded by “/ **” and “* /”. Therefore, in this step, it is necessary not only to detect a mere comment part but also to detect a comment part that is a target of Javadoc. However, as a rule specific to the Java source code check program 110, when the “@author” tag is detected from an arbitrary comment, or the program creator name is described using a description method other than “@author”. However, this is not the only case. In any case, it is sufficient that the name of the program creator is described in the comment and the Java source code check program 110 can recognize this.

(Java source code check procedure: Step 3)
The Java source code check program 110 extracts the program creator name described in the “@author” tag from the comment part specified in step 2. In the example illustrated in FIG. 2, the program creator name is “AUTHOR — 001”.

(Java source code check procedure: Step 4)
The Java source code check program 110 counts the number of steps of the Java class described in the Java source code 200. Since the Java language has a rule that one Java class is described in one Java source code 200 file, the number of lines of the Java source code 200 may be counted. In the example shown in FIG. 2, the number of steps of the HelloWorld class is 25.

(Java source code check procedure: Step 5)
The Java source code check program 110 executes steps 1 to 4 for all the Java source codes 200 to be subjected to quality inspection.

(Java source code check procedure: Step 6)
The Java source code check program 110 counts the number of steps per Java class for each program creator. Specifically, the number of steps may be added for each program creator extracted in step 3, and the number of steps may be further divided by the number of Java classes created by the program creator.

(Java source code check procedure: Step 7)
The Java source code check program 110 outputs the result of step 6 in the form of file output, screen output, or the like.

  The operation of the Java source code check program 110 has been described above by taking the process of checking the source code of FIG. 2 as an example.

<Embodiment 1: Summary>
As described above, the Java source code check program 110 according to the first embodiment aggregates the number of steps per class for each creator of the Java source code 200 and outputs the result. By using this result, the tendency of the class size for each program creator can be grasped. As a result, a program creator who tends to create an extremely large Java class can be encouraged to improve the class by dividing the class. As a result, the quality of the Java source code 200 is improved.

  Also, the Java source code check program 110 according to the first embodiment extracts the program creator name from the “@author” tag of the Java source code 200. This eliminates the need to manage information such as the name of the program creator separately from the Java source code 200. Without this function, it is necessary to manage the attribute information of the program creator separately from the Java source code 200, resulting in a work load that is not directly related to the source code quality check. In this regard, according to the Java source code check program 110 according to the first embodiment, since the name of the program creator is acquired from the Java source code 200 itself, such work burden does not occur, and the tabulation work for each program creator is automated. This is advantageous in that it can be done. The same applies to the following embodiments.

<Embodiment 2>
In the second embodiment of the present invention, a method in which the Java source code check program 110 detects a comment-out portion in the Java source code 200 will be described. The configuration of the Java source code check program 110 and the surrounding environment is the same as that of the first embodiment. The method described in the first embodiment and the method described in the second embodiment may be used in combination or may be used individually.

  The comments in the Java source code 200 include general comments given by the program creator for the purpose of writing notes, explaining the role of classes and methods, and comments commented out to invalidate old Java instructions. Of these, the commented out old Java instruction is not preferable from the standpoint of quality maintenance such as maintainability because it is left unreadable if it is left in the Java source code 200.

  Therefore, in the second embodiment, a method of extracting only the comment-out portion after distinguishing the comment-out portion in the Java source code 200 from other general comments will be described.

  FIG. 3 shows a sample Java source code 200. Although generally the same as the sample shown in FIG. 2, comments are added to the 29th to 30th lines and the 17th to 21st lines. The breakdown of these comments is as follows.

(Figure 3: Comment on line 30)
The 30th line is a commented out old version of the Java instruction described in the 32nd line. “Comment out” means that a predetermined symbol is assigned so that an unnecessary part of Java source code is invalidated so that the part is treated as a comment. Here, “//” is added to the beginning of a line to indicate that the line is handled as a comment.

(Figure 3: Comment on line 29)
The 29th line seems to have been given as a note by the program creator when commenting out the 30th line. Such comments can be categorized as general comments, unlike comments that comment out Java instructions.

(Figure 3: Comments on lines 17-21)
The 17th to 21st lines are commented by being surrounded by “/ *” and “* /”. Of these, the 18th and 19th lines are commented out of the old source code as in the 30th line. The 20th line is a general comment given as a memo by the program creator.

  As illustrated above, general comments and comment-outs are mixed in the comment portion. From the viewpoint of maintainability of the Java source code 200, it is not preferable that the old source code remains, so only the commented-out portion is detected in the second embodiment. The procedure will be described below.

(Comment out detection procedure: Steps 1-2)
These steps are the same as steps 1-2 in the first embodiment.

(Comment out detection procedure: Step 3)
The Java source code check program 110 adds an end terminal (semi-colon) of a Java statement, a start parenthesis “{” or “(” in the Java language, or in the Java language to the end of the line determined to be a comment line in Step 2. It is determined whether or not the closing parenthesis “}” or “)” exists. Lines where these exist at the end of a line are considered to be commented out lines. Only one of these parentheses may be detected.

(Comment out detection procedure: Step 3: Supplement)
In this step, it is assumed that a semicolon, start parenthesis, or end parenthesis is present at the end of the line because if it exists at the end of the line, it is assumed that the line describes a Java instruction. is there. For example, the 30th line in FIG. 3 describes the Java statement before commenting out, so there is a semicolon that is the end terminal of the Java command at the end. Similarly, in the 18th to 19th lines, there are opening and closing parentheses frequently used in Java source code. Since these parentheses are described at the end of a line, it is considered that a line having these parentheses at the end of the line describes a Java instruction.

(Comment out detection procedure: Step 4)
The Java source code check program 110 outputs the result of step 3 in the form of file output, screen output, or the like.

  The operation in which the Java source code check program 110 detects the comment-out portion has been described above using the source code of FIG. 3 as an example.

<Embodiment 2: Summary>
As described above, the Java source code check program 110 according to the second embodiment distinguishes between the commented out portion of the Java instruction and the general comment portion, and detects only the portion of the commented out Java instruction. As a result, it is possible to detect the Java source code 200 in which the old Java instruction remains, so that the maintainability of the Java source code 200 can be improved.

  In addition, although it is difficult to distinguish between a general comment part and a comment-out part, the Java source code check program 110 according to the second embodiment pays attention to a symbol unique to the Java instruction at the end of the line and appropriately detects comment-out. succeeded in. Thereby, the comment-out part can be detected appropriately.

<Embodiment 3>
The Java source code check program 110 may be used in combination with the above-described first and second embodiments, or separately, and may total the ratio of comment lines to the total number of lines in the Java source code 200 for each program creator. it can.

  In general, there is an appropriate range for the ratio of comment lines to the total number of lines in the Java source code 200. Even if there are too few comments, it is not preferable because the contents of the Java source code are difficult to understand, and if there are too many comments, it is not efficient.

  Therefore, the Java source code check program 110 according to the third embodiment aggregates the ratio of comment lines to the total number of lines in the Java source code 200 for each program creator, and the ratio of comment lines tends not to be within the appropriate range. Identify the program creator.

  Specifically, for each program creator name listed in the “@author” tag, the total number of steps and the number of comment lines in the created Java source code 200 are counted, and the latter is divided by the former to obtain the ratio. That's fine. The calculation result is output in the form of file output, screen output, or the like.

<Embodiment 4>
The Java source code check program 110 can calculate the number of classes created for each program creator in combination with Embodiments 1 to 3 described above or separately from them.

  If only a specific program creator has an extremely large number of classes, it is assumed that the program creator has created a Java class by copying the existing Java source code 200 or the like. Since this leads to deterioration in the quality of the program, in order to detect such an action, the number of classes created is totaled for each program creator and output in the form of file output, screen output, and the like.

  On the other hand, even when the number of classes created by only a specific program creator is extremely small, it is assumed that the program creator has some problem or lack of skills. From the viewpoint of such development progress management, it can be said that the method according to the fourth embodiment is useful.

<Embodiment 5>
The Java source code check program 110 can also add up the cyclic complexity of the methods in the Java class for each program creator in combination with Embodiments 1 to 4 described above or separately from them.

  The cyclic complexity is generally used as an index representing the complexity of a method. This is mainly a technique in which a method is treated as having a high degree of complexity when there are many branches in the method. For example, processing such as branching in an if statement or calling another method in a method corresponds to branching.

  The cyclic complexity is preferably 10 or less. If the cyclic complexity exceeds 50, the test is impossible, and if it exceeds 75, any change will cause a false correction. The degree to which the cyclic complexity is allowed may be appropriately determined by a person using the Java source code check program 110.

  It has been empirically known that the complexity of the method shows a certain tendency for each program creator. Therefore, the Java source code check program 110 according to the fifth embodiment adds up the cyclic complexity of the method created by the program creator for the methods exceeding the reference value of the check rule, and further displays the summation result for each program creator. , File output, screen output, etc. This makes it possible to identify program developers who tend to create complex methods.

  100: Computer, 110: Java source code check program, 200: Java source code, 300: Check rule data.

Claims (6)

A program for causing a computer to execute processing for checking the quality of Java (registered trademark) source code,
A reading step of reading Java source code from a storage device;
Creation of detecting a tag portion describing the creator name of the Java class described in the Java source code from the comment portion described in the Java source code, and extracting the creator name from the tag portion The person extraction step,
A counting step for counting the number of steps of the Java class;
Executing the reading step, the creator extracting step, and the counting step for one or more Java source codes;
Counting the number of steps per Java class for each creator and outputting the results;
A Java source code check program characterized in that In the computer,
The comment part described in the Java source code is distinguished from a part commented out of a Java instruction and a general comment part, and a comment out detection step of detecting only a part commented out of the Java instruction is executed. The Java source code check program according to claim 1. In the comment out detection step, the computer
Reading one line of the Java source code;
A comment line determination step for determining whether or not the line read in the line reading step is a comment line;
Java instruction determination step for determining whether or not there is an end terminal of a Java statement, a start parenthesis in Java language, or an end parenthesis in Java language at the end of the line determined to be a comment line in the comment line determination step When,
In the Java instruction determination step, if it is determined that the end terminal, the start parenthesis, or the end parenthesis is present at the end of the line, the line is determined not to be a general comment line but to a comment-out line in which the Java instruction is commented out. When,
The Java source code check program according to claim 2, wherein: In the computer,
Calculating the ratio of comment lines to the total number of lines for all the Java source code created by one creator;
Summing up the percentages for each creator and outputting the results;
The Java source code check program according to any one of claims 1 to 3, wherein: In the computer,
The Java source code check program according to any one of claims 1 to 4, wherein a step of counting the number of Java classes created for each creator and outputting the result is executed. In the computer,
Calculating a cyclic complexity of a method in the Java class;
Summing the cyclic complexity for all the Java classes created by one creator,
Aggregating the summation results for each creator and outputting the results;
The Java source code check program according to claim 1, wherein the Java source code check program is executed.

Images