JP2009104290A - Software product management system, method, and its program - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To provide a software product management system, method and its program, for improving efficiency of software development. <P>SOLUTION: A computer stores a plurality of elements for achieving the behavior of software and a dynamic product configured of a task including at least one element among the respective elements as a parameter and link information showing relevance between the parameter of the task and each data in a concept system repository 14, and when the content of the elements stored in the concept system repository 14 is changed by an information input part 12, the computer extracts the task including the parameter associated with the element from the concept system repository 14 based on the link information. <P>COPYRIGHT: (C)2009,JPO&INPIT

Description

  The present invention relates to a software product management system, a method, and a program therefor, which use a computer to identify an influence point of another software product based on a change in contents included in a software product created in software development.

  In software development, not only source code but also a user request, a simplified flow of software operation, and a document such as a design document for creating source code (hereinafter referred to as upstream product) are created as software products. Is done. These upstream deliverables are important for developing software that helps developers understand and meets user requirements during software development. However, when a software product that has already been created is changed due to a change in functionality during software development or operation, the software's functions must be accurately reflected. Other software artifacts related to the product will also need to be changed. In this case, there is a problem that as the number of software products increases, it becomes difficult to specify related software products and to specify a changed part in the software products. Therefore, various identification methods have been studied so far.

  By the way, software deliverables define dynamic deliverables that express dynamic information (tasks) for defining the behavior of the software to be developed, and data information necessary for the software to execute the behaviors. Static artifacts exist. However, in the conventional technology, when a static product is changed, it is difficult to specify a dynamic product that is affected by the change and an affected part thereof.

  For example, with the UML (Unified Modeling Language) tool described in Non-Patent Document 1, it is possible to save each created software product in an electronic folder for each function, so it is possible to grasp other related software products. Is possible. However, only the software product affected by the change can be specified by this, and it is difficult to specify which part of the description contents of the product is affected.

  In Non-Patent Document 2, it is possible to specify the software product affected by the change and the affected part, but the target software product is limited only to the screen transition diagram and struts-config.xml. It is difficult to handle various dynamic products created during software development.

  Furthermore, in Non-Patent Document 3, as in Non-Patent Document 2, it is possible to specify the software product affected by the change and the affected part, but the software product to be specified is only the source code, It is difficult to specify upstream deliverables such as user requirements and design documents.

  Furthermore, Non-Patent Document 4 proposes a method for identifying software deliverables and their affected parts, with the upstream deliverables such as user requirements and design documents, and the downstream deliverables such as source code as identification targets. However, there is no specific description on how to associate each software product.

Further, in Non-Patent Document 5, it is possible to specify a change place between dynamic deliverables representing the functional operation of software, such as a UC description or a sequence diagram, but as in a glossary or a class diagram, When the static product representing the data handled by the software function is changed, it is difficult to identify the dynamic product affected by the change and the affected part.
“ENTERPRIZE ARCHITECT”, [online], Spark Systems Japan Co., Ltd., [Search February 21, 2007], Internet <URL: http://www.sparxsystems.jp/ea.htm> Ohira et al. “Proposal of Traceability Realization Method Using Metamodel in Struts Framework”, Information Processing Society of Japan Research Report, November 2005, pages 33-40 Yamada et al. "Software change support based on functional model", IEICE Transactions D-2, vol. J73-D-2, no. 10, October 1990, pp. 1770-1778 Table et al. "Support of system evolution by link between UML models (2)", IEICE Technical Report, KBSE 2004-1, May 2004 Inoue et al. “Proposal of Propagation Location Identification Method in Product Change”, IEICE General Conference Proceedings, March 2007, p.549

  As described above, in the conventional example, it is difficult to specify the dynamic product affected by the change of the static product and the affected part, which hinders efficient software development.

  The present invention has been made in view of the above problems, and an object of the present invention is to provide a software product management system, method, and program thereof that can improve the efficiency of software development.

  In order to achieve the above object, the software product creation system according to the present invention uses a computer to identify an influence location of another software product based on a change in content included in the software product created in software development. A software product management system comprising: an information input unit; a plurality of data for realizing software behavior; and a task including at least one of the data as parameters Storage means for storing the task parameters and link information representing the relationship between each data, and when the content of the data stored in the storage means is changed by the information input means, the data is associated with the data. Tasks including parameters are extracted from storage means based on link information And a specifying unit that.

  In addition, in order to achieve the above object, the software product creation method of the present invention uses a computer to determine the influence points of other software products based on changes in the contents included in the software product created in software development. A software product management method for identifying the software product, the computer comprising a plurality of data for realizing software behavior, a software product comprising a task including at least one of the data as a parameter, A task parameter and link information representing the relationship between each data is stored in a predetermined storage unit, and when the content of the data stored in the storage unit is changed by a predetermined information input unit, it is associated with the data. Tasks including the parameters are extracted from the storage unit based on the link information.

  Furthermore, the software product management program of the present invention causes the computer to execute the software product creation method in order to achieve the object.

  As a result, when the content of the data for realizing the behavior of the software is changed by a predetermined information input unit, a task including a parameter associated with the data is extracted from the storage unit based on the link information. The task associated with the data can be easily specified simply by changing the content of the data for realizing the behavior of the software.

  According to the software product creation system, method, and program therefor of the present invention, the task associated with the data can be easily identified simply by changing the content of the data for realizing the behavior of the software. A task affected by a change of a static product including data can be specified as an affected part, and a dynamic product composed of the task can be specified as a software product affected by the change. Accordingly, the efficiency of software product change work can be improved and the quality of the software product can be improved, so that the efficiency of software development can be greatly improved.

  An embodiment of the present invention will be described below with reference to the drawings.

<Premise>
Software deliverables include dynamic software deliverables (hereinafter referred to as dynamic deliverables) expressing dynamic information (tasks) for defining the behavior of software to be developed, and the software to be developed. There is a static software product (hereinafter referred to as a static product) that defines data information necessary for realizing the above, and in this embodiment, when the content of the static product is changed The software product management system that identifies the dynamic product affected by the and the affected part is described.

  A software product management system 10 according to the present invention comprises a computer mainly composed of a well-known CPU. As shown in FIG. 1, a display unit 11, an information input unit 12, a product repository 13, a concept system repository 14, and a control. It consists of part 15.

  The display unit 11 is a module for displaying information, such as a liquid crystal display, and displays a product drawing screen 20 as shown in FIG. 2 under the control of the control unit 15.

  The information input unit 12 is a module for inputting information, such as a keyboard and a mouse, and transmits input information to the control unit 15.

  The product repository 13 is a module for storing dynamic products and static products created in the software development process.

  The concept system repository 14 is a module that stores a task structure, a parameter structure, link information, and a product rule, which will be described later.

  The control unit 15 is a module that is connected to the modules 11 to 14 and delivers information between the modules 11 to 14 or information obtained by combining information between the modules 11 to 14. The control unit 15 is provided with a storage device such as a ROM, and the control unit 15 controls the modules 11 to 14 by executing a program stored in the storage device.

  The product drawing screen 20 includes a dynamic product drawing unit 21 for drawing a dynamic product to be created or specified, and a static product for displaying a static product to be created or changed. It consists of a drawing unit 22, and it is possible to use the information input unit 12 to create dynamic products and to select and change data defined in static products. . In addition, the dynamic product drawing unit 21 is provided with a registration instruction unit (not shown) for registering the created dynamic product in the product repository 13, and is registered using the information input unit 12. Can be instructed. Further, the product drawing screen 20 is provided with a product selection unit (not shown) for selecting a dynamic product or a static product to be created / changed using the information input unit 12. .

<Formulation of dynamic product task>
In the dynamic product, behavior for functions realized by software is described as a flow of a plurality of tasks. This one task 30 is expressed as consisting of five elements: an input subject 31, an output subject 32, an operation 33, an input parameter 34, and an output parameter 35. When the task is expressed in natural language, the input subject 31, the output subject 32, the action 33, and the parameters 34 and 35 correspond to the subject, indirect object, predicate, and object, respectively. For example, as shown in FIG. 3, the input subject 31 of the task “Operator inputs OLT (Optical Line Terminal) information to the terminal” is “operator”, the output subject 32 is “terminal”, and the operation 33 is “input”. ”And the input parameter 34 is“ OLT information ”. When a task is expressed from a sequence diagram message in UML, the task 30 is shown as in FIG. The structure expressed as in FIG. 3 and FIG. 4 is called a task structure, and tasks and messages included in the dynamic product created by the dynamic product drawing unit 21 are converted into a task structure. Stored in the concept system repository 14.

<Formalization of static artifacts>
In the static product, a plurality of data information (parameter 40) used in the function realized by the software is described. That is, the parameters 34 and 35 of the task 30 included in the dynamic product are set based on the contents of the parameters 40 included in the static product. As shown in FIG. 5, each parameter 40 is expressed as comprising three elements: a set 41, an element 42, and a relation 43. For example, when expressing a class diagram as an example of a static product, as shown in FIG. 6, the class name is set in parameters 41a and 41b of parameters 40a and 40b, the class attribute is in elements 42a, 42b and 42c, Associations between classes correspond to relations 43, respectively. Further, an attribute 42a called "attribute 1" and an element 42b called "attribute 2" are connected to a set 41a called "class 1", and a class 2 attribute is connected to a set 41b called "class 2". , That is, an element 42c called "attribute 3" is connected. Further, the set 41a “class 1” and the set 41b “class 2” are connected to each other by a relation 43 “related”. The structure expressed in this way is referred to as a parameter structure, and each parameter included in the static product is stored in the concept system repository 14 in a state converted to the parameter structure. In this case, all the parameters included in the static artifacts are formalized and stored, so that static artifacts expressed in various forms such as natural language, UML, unique graphics, etc. can be shared. It becomes possible to handle.

<Product rule>
Software deliverables created in software development are first created from an overview and detailed as the development process proceeds. In a dynamic product, the most abstract software product such as UC (Use Case) is created first, and software products such as activity diagrams and sequence diagrams are created as the process progresses. The function is detailed. Similarly, for static products, a glossary is first created, and as the process proceeds, products such as a data analysis model (class diagram) and a table design drawing are created, and parameters are refined. When creating a dynamic product, the parameters described in the static product are used. However, the number of static products required to create one dynamic product may be limited to several types. it can. For example, when creating a UC, the parameters necessary to represent the UC task are described in the glossary. When creating a sequence diagram, the parameters necessary to represent the sequence diagram message Is a class diagram. As described above, when a dynamic product is created by associating a static product used when creating a certain dynamic product in advance as shown in FIG. Can be easily acquired. The product constraint information (hereinafter referred to as a product rule) representing this association is configured as shown in FIG. 7 and stored in the concept system repository 14. In the present embodiment, although one product rule is used, it may be stored as a plurality of pieces of information for each correspondence relationship between a static product and a dynamic product.

<Repository>
The product repository 13 stores dynamic products and static products created by the developer. The concept system repository 14 stores a task structure corresponding to a dynamic product and a parameter structure corresponding to a static product. That is, the conceptual system repository 14 stores a plurality of parameters for realizing the behavior of software in a state where it can be extracted. The conceptual system repository 14 stores link information 50 that indicates which element 42 of the parameter structure each parameter 34, 35 of the task structure corresponds to.

  Since the contents of dynamic artifacts can be uniquely converted to task structures and the contents of static artifacts to parameter structures as described above, the task structure and parameter structure are stored in advance in the conceptual system repository 14. The conversion process may be arbitrarily performed on the dynamic and static artifacts stored in the artifact repository 13. Conversely, dynamic and static artifacts need not be stored in the artifact repository 13 in advance, and the task structure and parameter structure stored in the concept system repository 14 can be arbitrarily converted. You may make it produce each deliverable.

<Product creation>
The developer selects a dynamic product to be created in the product selection unit of the product drawing screen 20. At this time, the control unit 15 acquires, from the product repository 13, the static product including parameters that can configure the task of the dynamic product to be created based on the product rule stored in the concept system repository 14. At the same time, the parameter structure corresponding to the static product is acquired from the concept system repository 14. In this case, the acquired static product is displayed on the static product drawing unit 22 of the product drawing screen 20.

  Next, the developer creates a dynamic product in the dynamic product drawing unit 21. Here, when describing a parameter in the dynamic product, after selecting the parameter of the static product displayed in the static product drawing unit 22, the dynamic product displayed in the dynamic product drawing unit 21 is selected. By selecting the parameter insertion location of the deliverable, the parameter is added to the dynamic deliverable. In the present embodiment, the existing GUI function is used to move the pointer to the parameter displayed in the static product drawing unit 22 and click the mouse, and then the dynamic product drawing unit 21 displays the parameter. By clicking the parameter insertion location of the dynamic product, it is possible to describe the parameter in the dynamic product.

  At this time, link information 50 is generated by the control unit 15 between the element 42 of the selected parameter structure and the parameters 34 and 35 added to the task structure, and the link information 50 is stored in the concept system repository 14. .

  If the parameters required when creating a dynamic product are not displayed in the static product drawing unit 22, the developer creates a new parameter in the static product drawing unit 22. It is possible. In this case, when a parameter different from the parameter acquired from the conceptual system repository 14 is input by the information input unit 12, the control unit 15 causes the static product drawing unit 22 to display the input parameter. In this way, the created parameters can be added as the parameters 34 and 35 of the task 30 included in the dynamic product as described above.

  The necessary dynamic products are created by repeating the above operations.

<Product registration>
After creating the dynamic product, the developer instructs the registration instruction unit of the product drawing screen 20 to register the dynamic product. At this time, the control unit 15 stores the created dynamic product in the product repository 13, converts the dynamic product into a task structure, and stores the task structure in the concept system repository 14. When a parameter is added to the static product, the control unit 15 stores the static product including the added parameter in the product repository 13 and converts the static product into a parameter structure. Then, the parameter structure is stored in the concept system repository 14. In this case, the relationship between the dynamic product and the static product is expressed as shown in FIG. That is, FIG. 8B shows a part of the tasks of the dynamic product shown in FIG. 8A in the task structure, and FIG. 8D shows the static product in the parameter structure. This is shown in FIG. Here, an element corresponding to the data “aaa” described in the static product in FIG. 8D (enclosed by a one-dot chain line in the figure) and a part of the task 30 in FIG. 8B ( Parameters enclosed by a two-dot chain line in the figure) are associated by the link information 50. Further, the task 30 including the parameters associated by the link information 50 corresponds to the task or message (a part surrounded by a broken line in the figure) in FIG. Thus, a predetermined task or message of a dynamic product is associated with data of a static product via a task structure, a parameter structure, and link information.

<Identification of change deliverables / changes>
Assuming that the above-mentioned deliverable registration has been performed, a method for identifying other dynamic deliverables that need to be changed based on a partial change in the registered dynamic deliverables and the influence location thereof is shown in FIG. This will be described with reference to a flow diagram.

  First, the product designated by the developer is acquired and displayed on the product drawing screen 20 (step S1). Specifically, when the developer specifies a static product to be changed in the product selection unit of the product drawing screen 20, the control unit 15 loads the specified static product from the product repository 13. At the same time, the parameter structure is acquired from the concept system repository 14. Further, the control unit 15 displays the static product acquired from the product repository 13 on the static product drawing unit 22 of the product drawing screen 20. Then, the developer corrects the static product in the static product drawing unit 22.

  Next, the element corresponding to the corrected location of the static product corrected by the developer is specified using the parameter structure stored in the concept system repository 14 (step S2). Specifically, when the developer modifies the element of the static product in the static product rendering unit 22 of the product rendering screen 20, the control unit 15 uses the existing GUI function to modify the modified element. To identify.

  Next, a task structure parameter related to the identified element is identified based on the link information 50 (step S3). Specifically, the control unit 15 extracts a task including a parameter (hereinafter referred to as a related parameter) associated with the identified element by the link information 50 from the concept system repository 14. In this case, the control unit 15 identifies the extracted task as an affected part.

  Then, a dynamic product including the related parameter is acquired from the product repository 13 and displayed on the product drawing screen 20, and a portion corresponding to the related parameter is highlighted (step S4). Specifically, the control unit 15 acquires a dynamic product including the task extracted in step S3 from the product repository 13, and displays the dynamic product on the dynamic product drawing unit 21. At this time, the control unit 15 highlights the portion corresponding to the related parameter in the dynamic product displayed in the dynamic product drawing unit 21 so that it stands out from the portion corresponding to the other task. indicate.

  First, an operation when a sequence diagram as a dynamic product is created using a class diagram as a static product will be described. When creating a dynamic product, the product rule of FIG. 7 is used.

  The developer selects a sequence diagram in the product selection section of the product drawing screen 20. At this time, the control unit 15 acquires a class diagram having parameters that can configure a task (message) of the sequence diagram from the product repository 13 based on the product rule stored in the concept system repository 14. The acquired class diagram is displayed on the static product drawing unit 22 of the product drawing screen 20. An example of the class diagram is shown in FIG.

  Next, the developer creates a sequence diagram in the dynamic product drawing unit 21. In this example, the sequence diagram shown in FIG. 11 is created. In this case, the form of the product drawing screen 20 is shown as in FIG. In the sequence diagram of FIG. 10, the parameter necessary for the message “= getOltid ()” does not exist, so the developer must select the parameter of the class diagram displayed in the static product drawing unit 22. Add the necessary parameters to the message. Specifically, the developer uses the GUI function to move the pointer to the parameter displayed on the static product drawing unit 22 and click the mouse, and then the developer is displayed on the dynamic product drawing unit 21. The parameter is described in the dynamic product by clicking the parameter insertion position of the dynamic product.

  An example of this parameter addition will be described with reference to FIG. For example, when setting the attribute “portNum” of the class “Port” described in the class diagram as the input parameter of the message “= getOltid ()”, the developer first draws a static artifact. After clicking the part where “portNum” is displayed in the part 22 (the part surrounded by the one-dot chain line in the figure), “()” of the message “= getOltid ()” in the dynamic product drawing part 21 Click again at. At this time, the attribute “portNum” is set inside “()” (portion surrounded by a broken line in the figure).

  FIG. 14 shows the relationship between the task structure and the parameter structure when the above operation is performed. The task 60 shown in FIG. 14A includes an input subject 61 called “Register”, an output subject 62 called “Port”, an operation 63 called “getOltid”, an input parameter 64 called “portNum”, and “− Output parameter 65. 14B includes a set 71a “Port” and an element 72a “Portnum”. The parameter 70b includes a set 71b “OLT” and “olt”. -id "element 72b and" oltname "element 72c. Further, the parameters 70a and 70b are connected by a relation 73 called “Port”. Furthermore, since the input parameter 64 “portNum” is set based on the element 72c “portNum”, link information 80 is generated between them.

  When the developer instructs registration of the deliverable by the registration instruction unit, the control unit 15 registers the task structure, parameter information, and link information of FIG. The sequence diagram and the class diagram are registered in the product repository 13 by the control unit 15. In this case, the relationship between the sequence diagram and the class diagram is expressed as shown in FIG. That is, FIG. 15B shows the sequence diagram shown in FIG. 15A in the task structure, and FIG. 15C shows the class diagram in FIG. 15D in the parameter structure. It is. Here, the element 72a corresponding to the attribute “portNum” described in the class diagram of FIG. 15D and the input parameter 64 of the task 60 of FIG.

  With reference to FIG. 16, the operation for specifying the dynamic product affected by the change of the registered static product and the affected part will be described on the assumption that the product registration is performed. .

[Procedure 1]
When the developer specifies a class diagram in the product selection unit of the product drawing screen 20, the control unit 15 acquires the class diagram from the product repository 13, and sets the parameter structure corresponding to the class diagram to the concept system repository 14. Get from. Further, the control unit 15 displays the class diagram acquired from the product repository 13 on the static product drawing unit 22 of the product drawing screen 20. Then, the developer uses the information input unit 12 to correct the class diagram. In this example, in the class diagram of FIG. 16D, the attribute “portNum” of the class “Port” (portion surrounded by a one-dot chain line in the diagram) is changed.

[Procedure 2]
When the developer changes the attribute “portNum” of the class “Port” in the static product drawing unit 22 of the product drawing screen 20, the control unit 15 assigns the element corresponding to the corrected part of the class diagram to the conceptual system. The parameter structure stored in the repository 14 is used for identification. In this case, the control unit 15 specifies the correction location of the class diagram using the GUI function, and specifies the element corresponding to the location from the parameter structure. In this example, the element 72a “portNum” is specified in the parameter structure of FIG.

[Procedure 3]
The control unit 15 specifies the parameter of the task structure related to the element 72a “portNum” based on the link information 80. Specifically, the control unit 15 extracts a task including a related parameter associated with the element 72a by the link information 80 from the concept system repository 14. In this example, in the task structure of FIG. 16B, an input parameter 64 “portNum” is a related parameter, and a task 60 including this input parameter 64 is extracted.

[Procedure 4]
The control unit 15 acquires a sequence diagram including the related parameter from the product repository 13 and displays it on the product drawing screen 20, and highlights a portion corresponding to the related parameter. Specifically, the control unit 15 acquires a sequence diagram including the task extracted in step 3 from the product repository 13 and displays the sequence diagram on the dynamic product drawing unit 21. At this time, the control unit 15 causes the sequence diagram displayed on the dynamic product rendering unit 21 to highlight and display the location corresponding to the related parameter, so that the location corresponding to the other task is highlighted. . In this example, in the sequence diagram of FIG. 16A, a portion corresponding to the extracted task (a portion surrounded by a broken line in the drawing) is highlighted.

  Thus, when the data for realizing the behavior of the software, that is, the content of the attribute of the class diagram is changed by the information input unit 12, the task 60 including the parameter 64 associated with the element 72a corresponding to the attribute is obtained. Is extracted from the concept system repository 14 based on the link information 80, and it becomes possible to easily specify the task 64 associated with the attribute only by changing the content of the attribute of the class diagram.

  As described above, in the above embodiment, it is possible to easily identify a task related to the data by simply changing the data of the static product. Therefore, the task affected by the change of the static product is affected. In addition to specifying the location, the dynamic product made up of the task can be specified as the software product affected by the change. Accordingly, the efficiency of software product change work can be improved and the quality of the software product can be improved, so that the efficiency of software development can be greatly improved.

  In addition, since the dynamic product including the task identified as the affected part is displayed on the display unit 11, the developer can be notified of the dynamic product that is affected by the change of the static product.

  In addition, when displaying dynamic deliverables, the location corresponding to the task identified as the affected location is highlighted so that the developer can be surely notified of the location affected by the change in the static product. it can.

  In addition, said embodiment is only a specific example of this invention, and this invention is not limited only to the said embodiment. For example, the present invention can also be realized by installing a program having the above-described creation procedure on a known computer via a recording medium or a communication line.

The figure which shows the structure of the software product management system in one Embodiment of this invention. Figure showing the product drawing screen Diagram showing task structure Diagram showing task structure Diagram showing parameter structure Diagram showing the relationship between static artifacts and parameter structure Diagram showing outline of deliverable rule Diagram showing the relationship between dynamic and static artifacts Flow diagram showing the operation when identifying the location affected by the change Diagram showing an example of a class diagram Diagram showing an example of a sequence diagram Figure showing the product drawing screen when creating software products Figure showing the product drawing screen when creating software products Diagram showing the relationship between task structure and parameter structure Diagram showing the relationship between sequence diagram and class diagram Diagram showing the relationship between sequence diagram and class diagram

Explanation of symbols

  10 ... Software deliverable management system, 11 ... Display unit, 12 ... Information input unit, 13 ... Product repository, 14 ... Concept repository, 15 ... Control unit, 30,60 ... Task, 34,64 ... Input parameters, 35 , 65 ... output parameters, 40, 70a, 70b ... parameters, 50, 80 ... link information.

Claims (7)

A software product management system for identifying, using a computer, an affected part of another software product based on a change in content included in a software product created in software development,
The computer
Information input means;
Stores a plurality of data for realizing the behavior of software, a software product composed of a task including at least one of the data as a parameter, and link information indicating a relationship between the parameter of the task and each data Storage means for
When the content of the data stored in the storage unit is changed by the information input unit, the task includes a specifying unit that extracts a task including a parameter associated with the data from the storage unit based on the link information. Software product management system. The computer
The software product management system according to claim 1, further comprising display means for displaying a software product including a task extracted by the specifying means. The display means includes
The software product management system according to claim 2, wherein when displaying the software product, the part corresponding to the extracted task is displayed more prominently than the part corresponding to another task. A software product management method for identifying, using a computer, an affected area of another software product based on a change in content included in a software product created in software development,
The computer
Predetermined are a plurality of data for realizing the behavior of the software, a software product composed of a task including at least one of the data as parameters, and link information indicating a relationship between the parameter of the task and each data. Stored in the storage section of
When the content of the data stored in the storage unit is changed by a predetermined information input unit, a task including a parameter associated with the data is extracted from the storage unit based on link information. Object management method. The computer
The software product management method according to claim 4, wherein the software product including the extracted task is displayed on a predetermined display unit. The computer
6. The software product management method according to claim 5, wherein a portion corresponding to the task extracted when displaying the software product is displayed more prominently than a portion corresponding to another task.   A software product creation program for causing a computer to execute the method according to any one of claims 4 to 6.

Images