JP2006079212A - Design management method for program, design management system for program, design management device for program, and design management program for program - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To efficiently design a program under the type or definition of a standardized operation and source, and to improve the quality of a program by easily and surely taking the synchronization of design objects only by one changing work. <P>SOLUTION: The design management system 10 of a program is provided with a file server 12 for storing an entity file necessary for program design and a plurality of design terminals 14 connected to the file server 12. The file server 12 is provided with a repository 16 for storing meta data for storing configuration information of all entity files related with the program. The design terminal 14 reads the meta data from the repository 16, and adds a design operation to the meta data, and the contents of the design operation including entity data which have to be changed by the design work, that is, the entity data which are used by a design terminal in charge of the other design stage are reflected on single or a plurality of the entity files which have to be changed by the design work through the meta data. <P>COPYRIGHT: (C)2006,JPO&NCIPI

Description

  The present invention relates to a program design management method, a design management system, and these systems or methods that can perform design of the program simply and efficiently when developing a system realized by the program. Regarding the improvement of design management devices and design management programs that can be used, in particular, providing a comprehensive system development environment to prevent the occurrence of problems in the developed system and the effectiveness of the development assets accumulated so far It is about realizing utilization.

  Today, particularly in companies, in various aspects such as production, maintenance, and data management, the use of programs and various systems operated by information processing devices that perform predetermined processing using these programs, Businesses are being implemented smoothly and effectively. For this reason, many systems have been developed, but the development process up to the design, testing, operation and maintenance of the system realized by this program has been complicated and diversified by user requirements. Since it is very difficult to derive a specification that meets the requirements, as represented by RUP (RationalUnifiledProcess), in general, the mock-up is first presented to the request from the user, and then the external design document. The process of sharing the work for each process, such as creation of an internal design document, programming, and generation of a maintenance document, and repeatedly developing each of these processes is becoming mainstream.

  In this case, in each process, intermediate products such as design documents generated in the previous process are sequentially used to process the design work to be performed in the process. The deliverables are linked and related to each other. For this reason, in the development process, when a function needs to be added, specification changes, or problems occur, the results of design work that should be used in other processes as well as the processes directly related to the changed part. The product is also affected, and it is necessary to make frequent modifications and changes throughout each deliverable to achieve synchronization.

  In order to cope with such a situation, when correction or change is necessary in each process, the status is notified to the management source system so that the status of the correction change can be managed centrally (for example, patent It has been proposed to detect and notify a deliverable to be modified (see, for example, Patent Document 2).

  However, simply managing the information to be corrected or notifying each process does not necessarily ensure that the information is corrected and changed to the appropriate content. As a result, between the specification and the implementation file, etc. If there is no consistency among the deliverables and the synchronization is not properly performed, the quality of the system may be degraded, for example, a problem may occur in the developed system.

  Further, conventionally, it is necessary to change the number of objects to which the change is to be applied to one change request. For example, when there are three related objects, three correction operations require three objects. Modifications must be made to (1request 3changes 3documents). In this case, especially in the development process, as the downstream process (post-process side) goes to the process, the amount of related products gradually increases, which may be affected by the need for changes in other processes. As a result, the correction work is burdened with a large burden. For this reason, the possibility of the occurrence of human error cannot be fully denied, and as a result, if a malfunction or the like occurs, it will take time to find and correct it further. There is a risk of incurring a delay.

  It is also a cause of these synchronization problems, and the root cause of other problems such as inefficiency in conventional program design is that each person in charge of each design work in each design stage in conventional program design. The work is on different files that should be handled. That is, for example, in the past, the external design document A was created in the external design, and then the internal design document B was created in the internal design related to the detailed setting of the screen and the business logic. In order to build an environment in which the source code can be input and other programming can be performed in accordance with the external design document A and internal design document B created by reflecting these user requirements in the programming process. Create an XML format configuration file C according to A and B, and further adjust the data set D (programmer distribution set) necessary for programming including these design documents A and B and configuration file C into After providing the source file E etc., the programmer builds it separately for each different file. The it had done. For this reason, it is necessary to adjust each design work stage, which causes problems such as the number of processes required for development and the increase and complexity of documents to be maintained. It was desired.

  Furthermore, as system development becomes more complicated in this way, if the development procedure differs for each system development project, the rules that designers should refer to will gradually increase, causing confusion and development. The operation and maintenance of the system is also very difficult and requires a great deal of cost. For this reason, in recent years, for example, development by coding with a single text editor and development using an integrated development environment (IDE) have become mainstream. These IDEs can be used by plugging in various functions. Some IDEs can describe design documents as well as edit functions for describing source codes.

  In any case, in these conventional IDEs, although the development process, that is, the development operation can be unified, the contents of the design work are different for each system development project (each designed program). Since it was performed individually and individually for different files as described above, the types and definitions of the source code as the deliverables were not necessarily standardized or unified. For this reason, it is necessary to carry out design work after defining input / output definition, layout definition, screen operation definition, flow definition, and logic definition for each project, and as a result, conventionally, it consists of various sources. The system was built by the program, and it required a lot of labor to maintain it. At the same time, because the program source was disjoint in this way, even if the source file was accumulated as an internal asset, the asset could not be used effectively in the next new system development with a different development definition. There was a problem that development could not be maintained and managed efficiently.

Japanese Patent No. 3381931 Japanese Patent No. 3143004

  In view of the above problems, the problem to be solved by the present invention is that a program can be efficiently designed under standardized operations and types and definitions of sources, and at the same time, the developed assets are effectively utilized. In addition, it is possible to design programs in a short period of time by reducing work processes and enabling efficient development, and at the same time, it is possible to improve the quality of programs simply and reliably for synchronization between design objects. A design management method that can be used, and a design management system, a design management device, and a design management program that can be used for such a method.

  As a first means for solving the above problems, the present invention allows the design terminal connected to the file server to use the contents of the entity file necessary for designing the program stored in the file server. A design management method of a program for creating new data, which is another entity file necessary for designing a new program, from an entity file already stored in a file server by a design terminal, all related to the program Metadata should be generated and stored in the repository, and the design work should be changed through the metadata by reading the metadata from the repository and adding the design work to the metadata. Create an entity file by reflecting the contents of the design work on one or more entity files. Or there is provided a design method of managing programs and changes.

  As a second means for solving the above-mentioned problems, the present invention provides a method in which a plurality of design terminals in charge of various design stages are connected to a file server in the first solution means, and are shared among the plurality of design terminals. Design terminals that perform design work using the metadata, and are the actual data that should be changed by the design work, and the contents of the design work added to the metadata by each design terminal. It is intended to provide a program design management method characterized in that it is also reflected in entity data to be used in the system.

  As a third means for solving the above problem, the present invention provides a design management means that is set to be operable in a design terminal in the first or second solution means. There is provided a program design management method characterized in that only information necessary for a design work to be handled by the design terminal is extracted, read into the design terminal, and displayed as a work interface on the design terminal.

  The present invention provides, as a fourth means for solving the above-mentioned problem, in the design management means in the first to third solving means, wherein the design management means set to be operable in the design terminal is used in the design management means. Source code types and definitions that can be processed through metadata, file types, and other development standards are set, and by this design management means, program sources, documents, and other entity files that comply with the development standards set in advance through metadata The present invention provides a program design management method characterized by creating or changing a program.

  As a fifth means for solving the above-described problems, the present invention provides a new system skeleton that is designed to be operable in a design terminal in any one of the first to fourth solutions. A program design management method characterized by performing any one or more of creation, creation of a web page file, creation of a business logic file, creation of an event, and association of files generated by each creation operation Is to provide.

  According to the present invention, as a sixth means for solving the above-described problems, in any one of the first to fifth solving means, a repository for storing metadata is set in a file server. It provides a design management method.

  As a seventh means for solving the above-mentioned problems, the present invention provides a design management means for processing a design work that is set to be operable in a design terminal in any of the first to sixth solving means, The present invention provides a program design management method characterized by being installed in either or both of a design terminal and a file server.

  The present invention also provides the following design management system, design management apparatus, and design management program that can be used in the first to seventh solving means. That is, the present invention includes, as an eighth means for solving the above-described problem, a file server that stores an entity file necessary for designing a program, and a design terminal connected to the file server, This design terminal uses the contents of the entity file stored in the file server to create new data that is another entity file necessary for designing a new program from the entity file already stored in the file server. A design management system for a program, in which a file server has a repository for storing metadata that stores configuration information of all entity files related to the program, and the design terminal reads the metadata from the repository and stores the metadata. The design management system makes changes to the design work through metadata. There is provided a program design management system, characterized in that it comprises a design reflecting unit can for reflecting or contents of design work to a plurality of actual file singular create or modify the entity file.

  The present invention provides, as a ninth means for solving the above-described problems, a plurality of design terminals in charge of various design stages in the eighth solution means, wherein the plurality of design terminals store common metadata. The design reflection means uses the contents of the design work added to the metadata by each design terminal as the actual data to be changed by the design work and is responsible for other design stages. The present invention provides a program design management system characterized by being reflected in entity data to be used in a terminal.

  The present invention provides, as tenth means for solving the above-mentioned problem, in any of the eighth or ninth solving means, comprising design management means set to be operable in a design terminal, and design management means A program design management system characterized in that, from the metadata, only information necessary for the design work to be handled by the design terminal is extracted, read into the design terminal, and displayed on the design terminal as a work interface. It is to provide.

  The present invention provides, as eleventh means for solving the above-mentioned problems, in any of the eighth to tenth solving means, comprising design management means set so as to be operable in a design terminal. The source code type and definition that can be processed through the metadata in the design management means, the file type and other development standards are set in the means, and the program in accordance with the development standard preset through the metadata by the design management means The present invention provides a program design management system characterized by creating or changing source, document and other entity files.

  The present invention provides, as a twelfth means for solving the above-mentioned problem, in any one of the eighth to eleventh solving means, comprising a design management means set to be operable at a design terminal, and the design management means Is characterized by performing one or more of the following processes: creation of a new system skeleton, creation of a web page file, creation of a business logic file, creation of an event, and association of files generated by each creation work. To provide a design management system for the program to be executed.

  As a thirteenth means for solving the above-described problems, in any one of the eighth to twelfth solving means, a design management means configured to be operable at a design terminal and processing a design work, It is an object of the present invention to provide a program design management system which is installed in either one or both of a design terminal and a file server.

  According to the present invention, as a fourteenth means for solving the above problem, in any one of the eighth to thirteenth solving means, a design reflecting means is provided in either one or both of the design terminal and the file server. A program design management system characterized by the above is provided.

  The present invention uses, as a fifteenth means for solving the above-mentioned problems, the contents of an entity file stored in a file server connected to a file server in which an entity file necessary for program design is stored. A design design management device comprising a design terminal for creating new data, which is another entity file necessary for designing a new program, from an entity file already stored in a file server. Singular that should be modified by design work through metadata by reading the metadata storing the configuration information of all the entity files related to the program from the repository set in the file server and adding the design work to the metadata Create an entity file by reflecting the contents of the design work on one or more entity files Is to provide a design management device program characterized by comprising a design management unit that changes.

  According to the present invention, as a sixteenth means for solving the above problem, in the fifteenth solution means, the design management means changes the contents of the design work added to the metadata by the design terminal by the design work. The present invention provides a design management apparatus for a program characterized in that it is also reflected in entity data to be used in a design terminal in charge of other design stages.

  According to the present invention, as a seventeenth means for solving the above-described problem, in any one of the fifteenth and sixteenth solving means, the design management means is a design work to be handled by each design terminal in the metadata. The present invention provides a program design management apparatus characterized in that only necessary information is extracted, read into a design terminal, and displayed on the design terminal as a work interface.

  According to the present invention, as an eighteenth means for solving the above-described problem, in any one of the fifteenth to seventeenth solving means, the design management means includes source code that can be processed through metadata in the design management means. Type, definition, file type and other development standards are set, and design management means create or change program sources, documents and other entity files according to the development standards set in advance through metadata. The design management apparatus of the program to perform is provided.

  According to the present invention, as a nineteenth means for solving the above-described problem, in any one of the fifteenth to eighteenth solving means, the design management means creates a new system skeleton, creates a web page file, An object of the present invention is to provide a program design management apparatus characterized by performing any one or a plurality of processes among creation of a logic file, creation of an event, and association of files generated by each creation work.

  According to the present invention, as a twentieth means for solving the above-described problem, an entity file necessary for designing a program is stored and connected to a design terminal so that the contents of the entity file are used by the design terminal. A program design management device comprising a file server that creates new data, which is another entity file necessary for designing a new program, from an already accumulated entity file. The file server is associated with the program. It has a repository that stores the metadata that stores the configuration information of all the entity files to be processed, and the design terminal reads the metadata from the repository, and the contents of the design work added to the metadata by the design terminal through the metadata Created or modified by reflecting one or more actual files to be modified by design work It is intended to provide a design management system program according to claim which has a design reflecting means for storing the entity file.

  According to the present invention, as a twenty-first means for solving the above-mentioned problem, in the twentieth solution means, the file server is connected to a plurality of design terminals in charge of various design stages, The content of the design work added to the metadata by the design terminal is reflected in the entity data that should be changed by the design work through the metadata and should be used in the design terminal in charge of other design stages An object of the present invention is to provide a program design management apparatus characterized by storing a created or changed entity file.

  According to the present invention, as a twenty-second means for solving the above problem, in any one of the twentieth or nineteenth solving means, the file server comprises a design management means for processing a design work, and the design management means Provides a program design management device characterized in that it is set to be operable in a design terminal.

  According to the present invention, as a twenty-third means for solving the above-described problem, in the twenty-second solution means, the design management means obtains only information necessary for a design work to be handled by each design terminal in the metadata. A program design management apparatus characterized by being extracted, read into a design terminal, and displayed on the design terminal as a work interface.

  According to the present invention, as a twenty-fourth means for solving the above-described problem, in any of the twenty-second or twenty-third solution means, the design management means includes source code that can be processed through metadata in the design management means. Type, definition, file type and other development standards are set, and design management means create or change program sources, documents and other entity files according to the development standards set in advance through metadata. The design management apparatus of the program to perform is provided.

  According to the present invention, as a twenty-fifth means for solving the above-described problem, in any one of the twenty-second to twenty-fourth solving means, the design management means creates a new system skeleton, creates a web page file, An object of the present invention is to provide a program design management apparatus characterized by performing any one or a plurality of processes among creation of a logic file, creation of an event, and association of files generated by each creation work.

  As a twenty-sixth means for solving the above-mentioned problems, the present invention uses the contents of an entity file stored in a file server connected to a file server in which an entity file necessary for program design is stored. In relation to the program from the repository set in the file server to the design terminal that creates new data that is another entity file necessary for designing a new program from the entity file already stored in the file server The procedure for reading the metadata that stores the configuration information of all the entity files, the procedure for adding the design work to the read metadata, and the design work for one or more entity files that should be modified by the design work through the metadata To execute the procedure to create or change the entity file by reflecting the contents of It is to provide a gram design management program.

  According to the present invention, as a twenty-seventh means for solving the above-described problem, in the twenty-sixth solving means, the contents of the design work added to the metadata by the design terminal are changed by the design work in the design terminal. The present invention provides a program design management program for executing a procedure to be reflected in entity data to be added to entity data to be used in a design terminal in charge of another design stage.

  According to the present invention, as a twenty-eighth means for solving the above-described problem, in any one of the twenty-sixth and twenty-seventh solving means, the design terminal is further in charge of design work to be handled by each design terminal in the metadata. A design management program for a program for extracting only necessary information, reading it into a design terminal, and executing a procedure to be displayed on the design terminal as a work interface is provided.

  The present invention provides, as a twenty-ninth means for solving the above-described problems, a type and definition of a source code that can be processed through metadata in a design terminal in any one of the twenty-sixth to twenty-eighth solving means. A program design management program to set the type of development standards and other development standards and to execute procedures to create or change program sources, documents and other entity files in accordance with the development standards set in advance through metadata It is.

  According to the present invention, as a 30th means for solving the above-mentioned problems, in any one of the above 26th to 29th solving means, a design terminal creates a new system skeleton, creates a web page file, business logic The present invention provides a program design management program for executing a procedure for performing any one or a plurality of processes among file creation, event creation, and association of files generated by each creation work.

  According to the present invention, as a thirty-first means for solving the above problem, an entity file necessary for designing a program is stored and connected to a design terminal so that the contents of the entity file are used by the design terminal. The metadata that stores the configuration information of all the entity files related to the program to the file server that creates new data that is another entity file necessary for the design of the new program from the already accumulated entity file. A function to create a repository to be stored, and a function to reflect the contents of design work added to metadata read from the repository by the design terminal to one or more entity files to be changed by the design work through metadata. A program for realizing the above is provided.

  According to the present invention, as a thirty-second means for solving the above-mentioned problem, in the thirty-first solution means, the contents of the design work added to the metadata by the design terminal are changed by the design work in the file server. The present invention provides a program design management program for realizing a function to be reflected in entity data to be added to entity data to be used in a design terminal in charge of another design stage.

  According to the present invention, as a thirty-third means for solving the above problem, an entity file necessary for designing a program is accumulated and connected to a design terminal so that the contents of the entity file are used by the design terminal. A file server that creates new data, which is another entity file necessary for designing a new program, from the already accumulated entity file, and all related to the program from the repository set in the file server in the design terminal By loading the metadata that stores the configuration information of the entity file and adding the design work to the read metadata, the contents of the design work are reflected in one or more entity files that should be modified by the design work through the metadata. Providing a program to realize the function that enables processing

  The present invention provides, as a thirty-fourth means for solving the above-mentioned problem, in the thirty-third thirteenth means, the file server, the information necessary for the design work to be handled by each design terminal among the metadata to the design terminal. A design management program for a program for realizing a function that enables execution of processing to extract only the data and read it into the design terminal and display it on the design terminal as a work interface is provided.

  According to the present invention, as a thirty-fifth means for solving the above-mentioned problem, in any one of the thirty-third or thirty-fourth solving means, the file server can process the type and definition of the source code that can be processed through the metadata. A function that allows the design terminal to execute creation or modification of program sources, documents, and other entity files in accordance with development standards set in advance through metadata. A program design management program is provided.

  According to the present invention, as a thirty-six means for solving the above-mentioned problems, in any one of the thirty-third to thirty-fifth solving means, a file server, a new system skeleton on a design terminal, a web page file , Providing a design management program for a program that realizes a function to enable execution of one or more processes of creating business logic files, creating events, and associating files generated by each creation work To do.

  According to the present invention, as described above, a design work necessary for the design of a certain program, a source file, a maintenance document, etc. are not directly designed for the actual file itself, but related to the program. For metadata that stores configuration information of all entity files to be processed, read this metadata into the design terminal, edit it, and then write this edited content to the metadata to write the content to this metadata. The entity data can be created by reflecting the corresponding entity data existing in the path designation destination, so even if there are multiple corresponding entity files, it is necessary to work for each entity file. There is a real advantage that the efficiency of design work can be improved.

  In this case, in particular, according to the present invention, as described above, for each program to be designed, design work is performed using common metadata among a plurality of design terminals in charge of various design stages. This eliminates the need to perform design work on different targets at each design stage, thus eliminating development processes such as creating environment setting files for programming and creating file sets for distribution to programmers. Thus, there is an actual advantage that efficiency can be achieved by reducing the number of work processes and design can be realized in a short period of time.

  Similarly, according to the present invention, as described above, by simply writing to the metadata, the change / modification contents are reflected in a plurality of entity files including entity files to be used in other design terminals. Therefore, it is possible to maintain the consistency by automatically synchronizing multiple entity files used between multiple design terminals at the same time in one operation (1request 1change ManyDocuments), reducing the time, cost and time for synchronization. In addition to being able to reduce this, there is an actual benefit that the occurrence of defects can be prevented and the quality of the system by the designed program can be greatly improved.

  Further, according to the present invention, as described above, since only the information necessary for the design work that the design terminal should handle is extracted from the metadata and displayed on the design terminal as a work interface, The process suitable for the design stage can be easily performed through the GUI (graphic user interface) etc. for each design stage while using the metadata of the system, and the operation efficiency can be improved at the same time. There is an actual benefit that can be unified, the occurrence of human error can be suppressed, and the difference in personal skills among designers can be eliminated.

  Furthermore, according to the present invention, as described above, work is performed on the entity file through metadata, and the type and definition of source code that can be processed through this metadata, the type of file, and other development standards are set, and the metadata is set. Through the data, program sources, documents, and other entity files in accordance with this development standard are created or changed, so the standards of the source, etc. are unified within the standardized range, and input / output is performed each time the system is developed. It is no longer necessary to create a definition document for the system and layout, etc., and programs, designs, specifications, etc. as assets already accumulated by other system development etc. can be used effectively in other system development, It can be used effectively as information, and at the same time, if it is within a standardized range, workers etc. There is a practical benefits that can be carried out smoothly design work without being aware of the differences between the code and the like.

  As described above, if the repository for storing metadata is set as a file server for storing entity files, the relationship between the metadata and the entity file corresponding to the metadata can be easily and reliably constructed. There are real benefits that can be made.

  Similarly, the metadata editing work called by the design terminal is performed in the design terminal, but the process of reflecting the content of the metadata in which the edited content is written in the corresponding entity file is performed in each design terminal. In addition to being able to specify the path at the same time as writing to the data, according to the present invention, as described above, the design reflection means is set in the file server, and the file server receiving the metadata writing A command for creating or changing the attached entity file can be issued. In the latter case, there is an advantage that the processing work in the design terminal can be reduced and simplified.

  Further, the design management means (IDE engine) that performs the actual editing work needs to be set to be operable at least on the design terminal, but if the design management means (IDE engine) is set to be operable on the design terminal, the design terminal The present invention is not limited to the case where the design terminal itself is installed in itself and has the design management means. According to the present invention, as described above, the entity is installed in the file server and the entity exists in the file server. Service Provider) can be set as an application that can be used in the design terminal. In this case, the storage capacity of each design terminal is not occupied more than necessary, and at the same time, Easily build a system simply by installing or using only a server without any major configuration changes Therefore, it can be easily incorporated into an existing development system, and at the same time, there is an advantage that the initial introduction cost and labor can be simplified.

  An embodiment of the present invention will be described in detail with reference to the drawings. FIG. 1 shows a design management system 10 for implementing a design management method for a program according to the present invention. As shown in FIG. 2, the file server 12 and a plurality of design terminals 14 connected to the file server 12 are constructed.

  As shown in FIGS. 1 to 3, the file server 12 stores entity files necessary for program design. Here, as shown in FIG. 2, the entity files necessary for the design of the program are 1) a file for creating a program, and 2) a program to be created (a source file group consisting of source codes). Point to an executable program). That is, it is a file that is a design object that has been generated by a person in charge (developer) of each design work from the past. As an example of 1), for example, as shown in FIGS. External design document and screen image HTML document that should be generated in the external design stage to reflect the request as a design document, and internal design that details the contents of the external design as a design document for internal developers Internal design documents such as detailed screen design documents and business logic design documents to be generated at the stage, and input of source code according to external design documents and internal design documents created to reflect these user requirements, etc. A common layer is designed based on the configuration file group to be generated in the common layer design stage for designing a common layer that can be programmed, and the source file group on which the program is based Is the point to the maintenance documents, etc..

  On the other hand, the plurality of design terminals 14 are connected to the file server 12 through the LAN, WAN, etc., as shown in FIG. 1, and are already stored in the file server using the contents of the entity file stored in the file server 12. New data, which is another entity file necessary for designing a new program, is created from the actual file. Each of the plurality of setting terminals 14 shares work necessary for program design and is responsible for various design stages. As the various design stages, for example, as shown in FIGS. 1 and 2, stages such as external design, internal design, common layer design, and programming can be set.

  Specifically, the design terminal 14 in charge of the external design stage is managed by an application designer, for example, as shown in FIG. 1, and is responsible for the design work reflecting the user's request as a design document and provided to the user Design screen lists and screen transitions in the operation of the system to create an external design document, and present a mockup (demonstration) to the user.

  The design terminal 14 in charge of the internal design stage, for example, is managed by the object designer and is responsible for the detailed design of the externally designed content as a design document for the internal developer. Based on the external design document, Detailed screen design such as screen layout definition, screen operation definition, screen output item definition, etc., business logic design for designing business logic such as business requirements and business rules that the user should consider in the business process to be performed by the system Do work.

  The design terminal 14 in charge of the common layer design stage is managed by the architect, and input of the source code and the like according to the external design document and the internal design document created by reflecting the user's request in the previous design stage Responsible for designing the common layer so that it can be programmed, and the ACBL layer (Application Common Base Layer), which is an application that is written in Java (registered trademark) and is a sample for each project, and an archive as an EJB component file (Ejb .jar) and so on, and in charge of design work to create sample programs written in Java (registered trademark).

  The design terminal 14 in charge of the programming stage is managed by a programmer, and is responsible for creating a target individual program (business application) by inputting source code based on these common layers and sample programs.

  Of course, the above assignment is merely an example, and can be arbitrarily set by the user of the design management system 10 of the present invention. However, in order to unify the development process and operation, the same design management system 10 is used. For users (development companies), it should be unified. In addition, in each design stage, it is needless to say that a plurality of design terminals 14 can further share the work. For example, in the internal design stage, detailed screen design and business logic design are performed by different design terminals 14. You can also.

  In the above hardware configuration, the file server 12 according to the present invention includes a repository 16 for storing metadata storing configuration information of all entity files related to the target program, as shown in FIGS. Have. On the other hand, as shown in FIGS. 1 and 2, each design terminal 14 includes design management means 18 that reads metadata from the repository 16 and processes design work. Therefore, in the present invention, the plurality of design terminals 14 do not directly work on different entity files at each design stage, but instead share common metadata for each project (each program to be designed). Use and design content using the contents of the entity file through this metadata. This eliminates the need to perform design work on different objects at each design stage, and eliminates development processes such as creating environment setting files for programming and creating file sets for distribution to programmers. Thus, efficiency can be reduced by reducing the number of work processes, and design in a short period of time can be realized.

  Specifically, the repository 16 can be set for each program to be developed (for each project), and is a total of metadata that collectively stores metadata that is configuration information of entity files related to the program. Is generated as Accordingly, the file server 12 has as many repositories 16 as the number of programs to be developed or the number of programs (projects) that have already been developed, and each design terminal 14 attempts to design from these repositories 16. By specifying (specifying) the program repository 16 and reading metadata from the repository 16, it is possible to select an arbitrary program design work. Can be involved. Further, as can be seen from FIGS. 2 and 3, these metadata are associated with a corresponding entity file by specifying a path or the like, and are associated with the entity file. Note that these metadata can be created from XML format or the like.

  Specifically, the design management means 18 is application software that functions as an IDE engine. In design work, the target repository 16 is designated and, as shown in FIG. Is read into each design terminal 14 (see arrow A in FIG. 2), and then design work is added to the metadata at each design terminal 14 (see arrow B in FIG. 2). Create or modify. That is, each design terminal 14 does not design the actual file itself as a direct target, but performs the design work using the metadata as a direct target through metadata as shown in FIG. More specifically, as shown in FIG. 4, the IDE engine as the design management unit 18 calls the metadata on the virtual memory space (auxiliary storage device) of the design terminal 14 and performs necessary editing work. The contents edited in the memory space are converted into metadata by overwriting (writing) the metadata on the file server 12 and stored in the repository 16 as metadata.

  Then, as shown in FIG. 4, by overwriting this metadata, the corresponding entity file associated with the metadata is also changed. Therefore, as shown in FIG. 3, when there are a plurality of entity files associated with this metadata, a plurality of associated entity files can be changed at the same time by working on one metadata. Even when these plurality of entity files are files to be used in other design terminals 14 in charge of different design stages, they are used in other design terminals 14 only by working in the design terminal in charge of the change work. The actual file to be changed is also automatically changed, so that it is not necessary to perform the change work for each design terminal 14 in charge of each design work.

  For this reason, it is necessary to add functions or change specifications according to user's request, or even when a problem occurs, a plurality of terminals used simultaneously between a plurality of design terminals in one operation. It is possible to maintain the consistency by automatically synchronizing the actual files (1request 1change ManyDocuments), and since it is possible to easily synchronize the actual files, it is possible to reduce the labor, time and cost for synchronization Needless to say, it is possible to prevent the occurrence of problems and to significantly improve the quality of the system by the designed program.

  In this case, the change to the metadata shown in FIGS. 2 to 4 can be reflected in the entity file by design reflection means (not shown) set in each design terminal 14. The reflection means can create or change the entity file by reflecting the contents of the design work on the single or plural entity files to be changed by the design work through the metadata. Specifically, this design reflection means can be realized as an application that specifies the path of the entity file corresponding to the changed metadata, and each design terminal 14 simultaneously modifies and changes the metadata when writing the metadata. By specifying the path of the entity file to be changed, the entity file can be changed in association with the storage of the metadata. Therefore, in this case, the design reflection unit can be realized as a part of the function of the IDE engine which is the design management unit 18 (as a part of the function of the design management unit 18). In addition, as shown in FIG. 3, it is possible to set the paths of a plurality of corresponding entity files for one metadata, especially when these plurality of entity files are used in different design stages. Can be reliably synchronized at different design stages.

  However, the design reflection means implementation method is not necessarily limited to the form mounted on each design terminal 14, and the design reflection means can be set in the file server 12. In this case, specifically, the design management means 18 in each design terminal 14 is in charge of conversion to metadata and storage, and then the design reflection means set in the file server 12 is the metadata. In response to the change, a change command (save command) for reflecting the change contents in an associated entity file by specifying a path in advance may be set.

  The IDE engine as the design management means 18 set in each design terminal 14 is, as shown in FIGS. 5 and 6, 1) creation of a new system skeleton, 2) creation of a web page file, and 3) work. It is set so that each process of creation of a logic file, 4) creation of an event, and 5) association of a file generated by each creation work can be performed. This will be described later with reference to FIG. 7 and subsequent drawings. Among these, for example, 1) Creation of a new system skeleton is a process required at the start of development, mainly at an initial external design stage (design terminal 14). 2) Web page file creation is also mainly handled at the design terminal stage 14 in charge of external design work, and 3) Business logic file creation is mainly This is an operation processed in the internal design stage (design terminal 14). In this way, since the required processing functions are different for each design stage, the IDE engine as the design management means 18 does not need to present exactly the same processing procedure in all the design terminals 14, and each design stage. It is possible to set so that a function suitable for work can be selected for each design terminal 14 in charge of.

  Specifically, the IDE engine, which is the design management means 18, provides a graphic user interface (GUI) suitable for the design work in charge as a work environment for each design terminal in charge of each design stage. Accordingly, the IDE engine, which is the design management means 18 appropriately set for each design terminal 14, is necessary for the design work to be handled by the design terminal 14 in the metadata from the repository 16 of the file server 14. Only the information can be extracted, and the extracted information can be read into the memory space of the design terminal 14 and displayed as a working interface. Therefore, the plurality of design terminals 14 can easily perform processing suitable for the design stage for each design stage while using common metadata, and can improve work efficiency. Operations can be unified, the occurrence of human errors can be suppressed, and personal skill differences between designers can be eliminated. In addition, as described above, the entity files can be synchronized with each other only by making changes in the category that they are in charge of, as described above, without being particularly conscious of the files themselves used in the design terminal 14 in charge of other design stages. And consistency is maintained throughout the design.

  The IDE engine, which is the design management means 18, is set with the type and definition of source code that can be processed through metadata in the design management means 18, the type of file, and other development standards. Specifically, this development standard includes not only usable languages (input / output definition) such as Java (registered trademark), C, C ++, XML, HTML, but also screen layout definition, screen operation definition, screen input Rules necessary for development procedures such as output item definition, flow definition, logic definition, and the like can be listed, and these are standardized and set in advance in the IDE engine which is the design management means 18. As can be understood from this, the items that can be set as the development standard can be appropriately selected as necessary, except for screen transitions and business logic that should be determined and changed according to the user's request. In addition, these development standards can be expanded by setting additional definitions as needed.

  This eliminates the need to set up these development procedure definitions every time a program is developed, and eliminates the need to create these definition documents in system development. Since it is created or changed to program sources, documents, and other entity files in accordance with the set development standards, standardization of the source of deliverables, etc. has been attempted within the standardized range, and it has already been developed by other system development, etc. Accumulated assets such as programs, design documents, specifications, etc. can be used effectively for the purpose of system development, or can be used effectively as in-house information.

  In this case, it should be noted that in the present invention, not only the programming language that can be used is decided, but also the IDE engine that is the design management means 18 for processing the common metadata as described above, In particular, it is possible to create or change an entity file that conforms to a unified standard by simply making the necessary edits along the GUI without being conscious of the definitions established as these development standards. . For this reason, as long as it is within the standardized range, an operator or the like can smoothly perform design work without being particularly aware of the difference in source code.

  Note that configuration management of the design management system 10 itself (management of update information of the entire design management system 10), that is, calling of metadata and other necessary files in each design terminal 14, and data to the repository 16 in the file server 12 Management of revision numbers (registration of versions) at the time of registration can be performed by a configuration management function set in each design terminal 14 or file server 12, as shown in FIG. Specifically, this configuration management function includes, for example, CVS (Concurrent Versions System), which is an existing free software developed as an open source, installed in the IDE engine as the design management means 18, and this design management is performed at the time of processing. In addition to being realized by calling a CVS plug-in from the IDE engine as means 18, it can also be set as a unique exclusive management merge function.

  For example, as shown in FIG. 5, in the process in the design management means 18 (IDE engine) of each design terminal 14, in addition to the metadata to be worked, a fixed file (static file) such as ACBL or an automatically generated file (Dynamic file) etc. are read into each design terminal 14 as a set of PJ files. At this time, for example, the fixed file and the automatically generated file are read by calling the CVS plug-in from the design management means 18 (IDE engine). Other processing and metadata can be read by the exclusive management merge function implemented as a unique function in the design management means 18 (IDE engine), and other processing can be performed.

  Next, an example of the processing procedure of the design management method by the design management system 10 of the present invention will be described with reference to FIG. As shown in FIG. 7, when a new program is developed after the IDE engine as the design management means 18 is started in the responsible design terminal 14, first, a design work for creating a system skeleton is performed. In this case, for example, in the IDE engine, which is the design management means 18 of the assigned design terminal 14 such as external design, first, a project property screen of the IDE engine as a working GUI is started, and a program to be designed from now on Determine the system name (hereinafter, the repository file name for accessing the corresponding metadata) and enter it. Next, by loading a library file in which common definitions etc. are set, performing necessary editing work, and saving, a set of skeleton sources of various entity files that will be the final object of design work in the future, The metadata of these entity files is generated in the file server 12 as the repository 16. In the case of this new development, for example, it is also possible to divert to the design of a new program by reading the metadata of a set of system skeletons approximated by a previously developed program and making changes. it can.

  On the other hand, if it is necessary to make changes to the system skeleton set, as shown in FIG. 7, after starting the IDE engine project property screen, enter the system name, select the project information, Read the metadata of the corresponding project, make necessary edits, save to the metadata, and simultaneously change the corresponding skeleton source.

  After the set of skeleton sources is newly generated in this way, for example, in the design terminal 14 in charge of external design, when a new web page file definition operation is performed next, as shown in FIG. The IDE engine web page generation wizard screen is started, a web page name is input, necessary input is performed, and the web page is saved. Thereby, metadata, an HTML file, and a setting file are generated.

  On the other hand, if it is necessary to change the definition of this web page file, as shown in FIG. 8, the web page property editor screen of the IDE engine is started, the web page name is input, and the corresponding file After selecting and reading metadata, making necessary edits, saving to the metadata, and simultaneously changing the corresponding HTML file.

  In addition, after the HTML file or the like is newly generated in the external design stage in this way, for example, in the design terminal 14 in charge of the internal design, when the business logic file is newly defined, As shown in FIG. 9, the business logic generation wizard screen of the IDE engine is activated, a business logic name is input, necessary input is performed, and the business logic is saved. Thereby, the metadata and the corresponding setting file are generated, and the newly created business logic definition is reflected in the already generated skeleton source set.

  On the other hand, when it becomes necessary to change the definition of the business logic, as shown in FIG. 9, the business logic file property editor screen of the IDE engine is started, the business logic name is input, and the related entity file is entered. After selecting and reading the metadata, making necessary edits, saving to the metadata, and simultaneously making changes to the corresponding configuration file, skeleton source set, and other entity files.

  Further, after the business logic is defined in the internal design as described above, for example, in the design terminal 14 in charge of the common layer design, a new event (executable process specification) definition work is subsequently performed. As shown in FIG. 10, the event generation wizard screen of the IDE engine is started, an event name is input, an event related property is set, and then the property is saved. Thereby, the metadata and the corresponding setting file are generated, and the newly created event definition is reflected in the already generated skeleton source set.

  On the other hand, if it becomes necessary to change the definition of this event, as shown in FIG. 10, the event property editor screen of the IDE engine is activated, and the metadata of the relevant entity file is selected and read. After making appropriate edits, save to the metadata, and at the same time, make changes to the corresponding configuration files and entity files such as a set of skeleton sources.

  Finally, the association work of each entity file generated as described above is performed. In this case, as shown in FIG. 11, the association editor screen of the IDE engine is started and the association is performed by the connector. Start each property editor according to the association destination, edit the property for each association destination, and save the property. Thereby, metadata and a corresponding setting file are generated.

  On the other hand, when it becomes necessary to change the association between the entity files, as shown in FIG. 11, the association editor screen of the IDE engine is activated, and the associated entity file metadata is selected and read. After performing the same associating process again, save to the metadata and simultaneously change the corresponding setting file.

  The above processing procedure is a general flow through the entire program design work (from external design to programming), and the contents to be worked at each design stage differ. For example, other than the design terminal 14 in charge of internal design In FIG. 9, it is not necessary to define the business logic file shown in FIG. 9, and an arbitrary processing operation can be set according to the design stage.

  As in the above embodiment, it is desirable to set the repository for storing the metadata in the file server 12 itself in which the entity files are accumulated, from the viewpoint of ease of association, but the correspondence with the data itself is ensured. If it can be set, it can also be set in another main storage device.

  Similarly, the IDE engine as the design management means 18 that actually performs the editing work is preferably installed in each design terminal 14 as in the above-described embodiment, but can be operated at least on the design terminal 14. Is not necessarily limited to a form that is installed in the design terminal 14 itself and the design terminal itself has the design management means. For example, the file is stored in the file server 12 or another server. The installed entity exists in the file server 12 or the like, and can be set as an application that can be used in the design terminal 14 in a form such as ASP (Application Service Provider). In this case, the capacity of the storage device of each design terminal 14 is not occupied more than necessary, and at the same time, only the server is set to be installed or usable without any particularly large setting change. Since the system can be easily constructed, it can be easily incorporated into an existing development system, and at the same time the initial introduction cost and labor can be simplified.

  The present invention can be applied to the development of a system realized by a program such as a web system.

It is the schematic of the design management system of the program of this invention. It is a conceptual diagram of the file structure in the design management system of the program of this invention. It is the schematic of the synchronization between the entity files through metadata in the program design management system of this invention. It is a follow chart of the synchronization between the entity files through metadata in the program design management system of the present invention. It is a schematic block diagram in the design management system of the program of this invention. It is a functional conceptual diagram of the design management means used for this invention. It is a flowchart which shows the procedure which produces a system skeleton by this invention. It is a flowchart which shows the procedure which performs the definition work of a web page file by this invention. It is a flowchart which shows the procedure which performs the definition operation | work of a business logic file by this invention. It is a flowchart which shows the procedure which performs the definition work of an event by this invention. It is a flowchart which shows the procedure which performs the correlation operation | work of each entity file by this invention.

Explanation of symbols

DESCRIPTION OF SYMBOLS 10 Program management system 12 File server 14 Design terminal 16 Repository 18 Design management means (IDE engine)

Claims (36)

The contents of the entity file necessary for designing the program stored in the file server are used by the design terminal connected to the file server, and a new one is created from the entity file already stored in the file server by the design terminal. A program design management method for creating new data, which is another entity file necessary for program design, which generates metadata storing configuration information of all entity files related to the program and creates a repository And storing the metadata from the repository by the design terminal and adding the design work to the metadata, whereby the single or plural entity files to be changed by the design work through the metadata Create or modify the entity file to reflect the contents of the design work Design management method of program characterized Rukoto. The program design management method according to claim 1, wherein a plurality of design terminals in charge of various design stages are connected to the file server, and the metadata common to the plurality of design terminals is used. The design work is performed, and the content of the design work added to the metadata by each design terminal is used in the design terminal that is the actual data to be changed by the design work and is in charge of other design stages. A design management method for a program, which is also reflected in the entity data to be executed. 3. The program design management method according to claim 1, wherein the design terminal in charge of the metadata should be in charge by the design management means set to be operable in the design terminal. A program design management method characterized in that only information necessary for a design work is extracted, read into the design terminal, and displayed on the design terminal as a work interface. 4. The design management method for a program according to claim 1, wherein the design management means configured to be operable in the design terminal can be processed through the metadata in the design management means. Source code types and definitions, file types, and other development standards are set, and the design management means creates or changes program sources, documents, and other entity files according to the preset development standards through the metadata. A program design management method characterized by: A program management method according to any one of claims 1 to 4, wherein a design management means configured to be operable in the design terminal creates a new system skeleton, creates a web page file, What is claimed is: 1. A program design management method comprising performing one or a plurality of processes of creation of a business logic file, creation of an event, and association of files generated by the creation operations. 6. The program design management method according to claim 1, wherein the repository storing the metadata is set in the file server. 7. The program design management method according to claim 1, wherein the design management means configured to be operable in the design terminal and to process the design work is the design terminal or the file server. A program design management method characterized by being installed on either or both of the above. A file server for storing an entity file necessary for designing a program; and a design terminal connected to the file server, wherein the design terminal uses the contents of the entity file stored in the file server. A program design management system for creating new data, which is another entity file necessary for designing a new program, from an entity file already stored in the file server, wherein the file server includes the program It has a repository that stores metadata storing configuration information of all related entity files, the design terminal reads the metadata from the repository, adds design work to the metadata, and the design management system includes: The single or multiple to be modified by the design work through the metadata The program design management system, characterized in that it comprises a design reflecting unit said to reflect the contents of the design work on the real file to create or modify the substantial file. 9. The program design management system according to claim 8, comprising a plurality of the design terminals in charge of various design stages, wherein the plurality of design terminals perform the design work using the common metadata. The design reflection means performs the contents of the design work added to the metadata by each of the design terminals at the design terminal that is the entity data to be changed by the design work and is in charge of another design stage. A program design management system, which is reflected in the entity data to be used. 10. The design management system for a program according to claim 8, further comprising design management means configured to be operable in the design terminal, wherein the design management means A program design management system, wherein only information necessary for a design work to be handled by the design terminal is extracted, read into the design terminal, and displayed on the design terminal as a work interface. 11. The design management system for a program according to claim 8, further comprising design management means set to be operable in the design terminal, wherein the design management means includes the design management means. The type and definition of the source code that can be processed through the metadata, the type of file, and other development standards are set, and the design management means sets the program source and document in accordance with the preset development standards through the metadata. A program design management system characterized by creating or changing other entity files. 12. The design management system for a program according to claim 8, further comprising design management means configured to be operable in the design terminal, wherein the design management means creates a new system skeleton. , A web page file creation, a business logic file creation, an event creation, and an association of files generated by each of the creation operations. . 13. The design management system for a program according to claim 8, wherein the design management means configured to operate in the design terminal and process the design work is the design terminal or the file server. A program design management system which is installed in one or both of the above. 14. The program design management system according to claim 8, wherein the design reflection means is provided in one or both of the design terminal and the file server. Design management system. A new program is created from the entity file already stored in the file server by using the contents of the entity file stored in the file server connected to the file server in which the entity file necessary for designing the program is stored. A design management apparatus for a program comprising a design terminal for creating new data that is another entity file necessary for the design of the program, wherein the design terminal is associated with the program from a repository set in the file server By reading the metadata storing the configuration information of all the entity files and adding design work to the metadata, the design work is performed on one or a plurality of the entity files to be changed by the design work through the metadata. Design to create or change the entity file to reflect the contents of Design management device program characterized by comprising a management unit. 16. The design management apparatus for a program according to claim 15, wherein the design management means is content data of the design work added to the metadata by the design terminal as entity data to be changed by the design work. A program design management apparatus characterized by being reflected in the entity data to be used in a design terminal in charge of another design stage. 17. The design management apparatus for a program according to claim 15, wherein the design management means outputs only information necessary for a design work to be handled by each design terminal in the metadata. A program design management apparatus which is extracted, read into the design terminal, and displayed on the design terminal as a work interface. The program design management device according to any one of claims 15 to 17, wherein the design management means includes a type and definition of a source code that can be processed through the metadata in the design management means, and a file Type or other development standard is set, and the design management means creates or changes a program source, document or other entity file according to the preset development standard through the metadata. Management system. 19. The design management apparatus for a program according to claim 15, wherein the design management means creates a new system skeleton, creates a web page file, creates a business logic file, creates an event. A program design management apparatus characterized by performing any one or a plurality of processes among the associations of files generated by the respective creation operations. An entity file necessary for the design of a program is accumulated and connected to a design terminal so that the contents of the entity file can be used by the design terminal to design a new program from the already accumulated entity file. A program design management apparatus comprising a file server for creating new data as another necessary entity file, wherein the file server stores metadata storing configuration information of all entity files related to the program A repository that has the design terminal read the metadata from the repository, and the design work content added to the metadata by the design terminal is to be changed by the design work through the metadata. The actual file created or changed by reflecting the actual file or a plurality of the actual files. Design management device program characterized by comprising a design reflecting unit for saving the file. 21. The design management apparatus for a program according to claim 20, wherein the file server is connected to a plurality of the design terminals in charge of various design stages, and the design reflection means is connected to the meta data by each design terminal. Created by reflecting the contents of the design work added to the data to the actual data to be used in the design terminal which is the actual data to be changed by the design work through the metadata and is in charge of other design stages or A program design management apparatus for storing a changed entity file. 22. The design management apparatus for a program according to claim 20, wherein the file server includes design management means for processing the design work, and the design management means is connected to the design terminal. A program design management apparatus characterized by being set to be operable. 23. The design management apparatus for a program according to claim 22, wherein the design management means extracts only information necessary for a design work to be handled by each design terminal from the metadata to the design terminal. A design management apparatus for a program, which is read and displayed on the design terminal as a work interface. 24. The design management apparatus for a program according to claim 22, wherein the design management means includes a type and definition of a source code that can be processed through the metadata in the design management means, and a file. A program source, a document or other entity file in accordance with the preset development standard is created or changed by the design management means through the metadata. Design management device. 25. The design management apparatus for a program according to claim 22, wherein the design management means creates a new system skeleton, creates a web page file, creates a business logic file, creates an event. A program design management apparatus characterized by performing any one or a plurality of processes among the associations of files generated by the respective creation operations. A new program is created from the entity file already stored in the file server by using the contents of the entity file stored in the file server connected to the file server in which the entity file necessary for designing the program is stored. Read the metadata that stores the configuration information of all entity files related to the program from the repository set in the file server to the design terminal that creates new data that is another entity file necessary for the design of A procedure for adding design work to the read metadata, and the entity file reflecting the contents of the design work in one or a plurality of entity files to be modified by the design work through the metadata A design tube for the program to execute Program. 27. A design management program for a program according to claim 26, wherein the content of the design work added to the metadata by the design terminal is substance data to be changed by the design work. A program management program for executing a procedure to be reflected in the entity data to be used in a design terminal in charge of another design stage. 28. A design management program for a program as set forth in claim 26 or claim 27, wherein only information necessary for design work to be handled by each design terminal among said metadata is further stored in said design terminal. A design management program for a program for executing a procedure of extracting and reading into the design terminal and displaying it on the design terminal as a work interface. 29. The program design management program according to claim 26, wherein a source code type and definition, a file type and other development standards that can be processed through the metadata are set in the design terminal. And a program design management program for executing a procedure for creating or changing a program source, a document or other entity file in accordance with the preset development standard through the metadata. A program design management program according to any one of claims 26 to 29, wherein a new system skeleton is created, a web page file is created, a business logic file is created, an event is created on the design terminal, A program design management program for executing a procedure for performing one or a plurality of processes among the associations of files generated by the creation operations. An entity file necessary for the design of a program is accumulated and connected to the design terminal, and the contents of the entity file are used by the design terminal to design a new program from the already accumulated entity file. A function to create a repository that stores metadata storing configuration information of all entity files related to the program in a file server that creates new data that is another entity file necessary for the program, and the design terminal A program for realizing the function of reflecting the contents of the design work added to the metadata read from the repository in one or a plurality of the entity files to be changed by the design work through the metadata. 32. The design management program for a program according to claim 31, wherein the content of the design work added to the metadata by the design terminal on the file server is entity data to be changed by the design work. A program design management program for realizing a function to be reflected in the entity data to be used in a design terminal in charge of another design stage. An entity file necessary for the design of a program is accumulated and connected to the design terminal, and the contents of the entity file are used by the design terminal to design a new program from the already accumulated entity file. Read the metadata that stores the configuration information of all the entity files related to the program from the repository set in the file server in the design server to the file server that creates new data that is another entity file necessary for A function for enabling execution of a process of reflecting the contents of the design work in one or a plurality of the entity files to be changed by the design work through the metadata by adding the design work to the read metadata A program to realize 34. The design management program for a program according to claim 33, wherein only the information necessary for the design work to be handled by each design terminal is extracted from the metadata to the design terminal to the file server. A design management program for a program that realizes a function that enables execution of processing that is read into a design terminal and displayed on the design terminal as a work interface. 35. The program design management program according to claim 33 or 34, wherein source file types and definitions, file types and other development standards that can be processed through the metadata are set in the file server. And a function for enabling the design terminal to create or change a program source, a document or other entity file in accordance with the preset development standard through the metadata. Design management program. 36. A design management program for a program according to any one of claims 33 to 35, wherein a new system skeleton is created on the design terminal, a web page file is created, a business logic file is created on the file server, A program design management program for realizing a function for enabling execution of any one or a plurality of processes among creation of an event and association of files generated by the respective creation operations.