JP2015084146A - Program development support apparatus and method - Google Patents

Abstract

PROBLEM TO BE SOLVED: To provide a technology of supporting program development so as to reliably improve system maintainability.SOLUTION: A program development support apparatus 20 includes: a common item storage section 22 which stores a common item which is prepared in advance and is referred by a plurality of programs; and a use history storage section 24 which stores a reference history of the common item stored in the common item storage section 22, for each of programs. The common items are specified to be input from the common item storage section 22 through a specific operation, which is different from an input operation for other codes, during program coding. The use history storage section 24 acquires a reference history of a program from a history of the specific operation during program coding, and stores it.

Description

  The present invention relates to a technique for supporting program development.

  Research on automatic program generation technology that automatically generates a program that satisfies the user's requirements described in a specification description that is easy for humans to understand has been conducted, and an automatic program generation tool has been developed (for example, Patent Document 1).

  Programs are often required to change after they are generated. Further, when changing a program, a so-called impact analysis is usually performed to measure the risk of change (for example, Patent Document 2).

  Although there is automatic program generation technology, the impact analysis at the time of program change is currently being performed manually, such as visual confirmation of all source code or keyword search using a text editor. When the system scale is small, there is no major problem even by manual work, but as the system becomes larger, the source code increases, the man-hours and difficulty of impact analysis increase, and the risk of missing surveys increases. In particular, since there are many cases where the program is changed after entering the operation phase, there are many cases where a few mistakes become a big problem, and the program change after the actual operation, especially the impact analysis, is the part where the developer uses the most nerve. Yes, it is the most annoying problem.

This problem is even more pronounced in the case of batch processing systems.
A batch processing system is a system in which a plurality of programs each carrying a plurality of processes are executed in a predetermined order. Hereinafter, these programs are referred to as “batch programs”. In one batch processing system, a common record (hereinafter referred to as “common item”) between a plurality of batch programs may be defined by different definition sentences in different batch programs.

  If the definition statements are different between batch programs even though they are common items, the efficiency of the program change and impact analysis at the time of change is low, and mistakes are likely to occur.

  The data item definition standardization apparatus disclosed in Patent Document 3 analyzes the source code of each batch program, and extracts the above-described common item definition sentence from each batch program. Next, for each common item, one definition sentence is selected from a plurality of definition sentences extracted for the common item and held as a standard copy. For each batch program, the source code is rewritten to refer to the standard copy for the common items.

  According to the method of Patent Document 3, since it is sufficient to change / inspect a standard copy for a common item when a program is changed or an impact analysis is performed, efficiency is improved and mistakes can be reduced.

JP-A-9-64887 JP 2003-044275 A Japanese Patent Application Laid-Open No. 7-104989

  However, it is not easy to extract common items by analyzing source codes of a plurality of programs. If the extraction of common items fails and different items are extracted as common items, the system may be seriously damaged and the maintainability of the system may be deteriorated.

  The present invention has been made in view of the above circumstances, and provides a support technology that can reliably improve the maintainability of a system for the development of a program.

  One aspect of the present invention is a program development support apparatus. The apparatus includes a common item storage unit that stores a common item that is created in advance and is referred to by a plurality of programs, and a usage history management unit that records a reference history of the common item for each of the programs.

  The common item is defined to be input from the common subject storage unit by a specific operation different from an input operation of another code when the program is coded.

  The usage history management unit obtains the reference history of the program from the history of the specific operation at the time of coding the program.

  Note that a representation of the support device in the above aspect replaced with a system or method, a program that causes a computer to operate as the support device, a recording medium that records the program, a program development system that includes the support device, and the like are also included in the present invention. It is effective as an embodiment.

  According to the technology of the present invention, program development can be supported and system maintainability can be reliably improved.

It is a figure which shows the program development system concerning 1st Embodiment. It is a figure which shows the program design management system concerning 2nd Embodiment. It is a figure which shows the example of the program development screen in the program design management system shown in FIG. It is a figure which shows the example of the coding screen for every kind of node. It is a figure which shows the image of the specific operation which inputs a common item (the 1). It is a figure which shows the image of the specific operation which inputs a common item (the 2). It is a figure which shows the image of the specific operation which inputs a common item (the 3). It is a figure which shows the example of a recording of reference history (the 1). It is a figure which shows the example of a recording of reference history (the 2). It is a figure which shows the example of a recording of reference history (the 3). FIG. 3 is a diagram for explaining impact analysis by the program design management system shown in FIG. 2 (part 1); FIG. 3 is a diagram for explaining impact analysis by the program design management system shown in FIG. 2 (part 2); FIG. 3 is a diagram for explaining impact analysis by the program design management system shown in FIG. 2 (part 3); FIG. 4 is a diagram for explaining impact analysis by the program design management system shown in FIG. 2 (part 4); FIG. 6 is a diagram for explaining impact analysis by the program design management system shown in FIG. 2 (part 5);

  Embodiments of the present invention will be described below with reference to the drawings. For clarity of explanation, the following description and drawings are omitted and simplified as appropriate. It should be understood by those skilled in the art that each element described in the drawings as functional blocks for performing various processes can be realized in various forms by a combination of hardware and software (program). It is not limited to any of the above. Note that, in each drawing, the same element is denoted by the same reference numeral, and redundant description is omitted as necessary.

  Further, the above-described program can be stored using various types of non-transitory computer readable media and supplied to a computer. Non-transitory computer readable media include various types of tangible storage media. Examples of non-transitory computer-readable media include magnetic recording media (for example, flexible disks, magnetic tapes, hard disk drives), magneto-optical recording media (for example, magneto-optical disks), CD-ROM (Read Only Memory) CD-R, CD -R / W, semiconductor memory (for example, mask ROM, PROM (Programmable ROM), EPROM (Erasable PROM), flash ROM, RAM (Random Access Memory)). The program may also be supplied to the computer by various types of transitory computer readable media. Examples of transitory computer readable media include electrical signals, optical signals, and electromagnetic waves. The temporary computer-readable medium can supply the program to the computer via a wired communication path such as an electric wire and an optical fiber, or a wireless communication path.

<First Embodiment>
FIG. 1 shows a program development system 1 according to the first embodiment. The program development system 1 is a computer for developing a plurality of batch programs constituting a batch processing system, for example, and includes a user interface (UI) 10 and a program development support device 20. In FIG. 1, only functional blocks necessary for describing the technique of the present invention are shown, and other components that are normally provided in this type of system are omitted.

  The UI 10 is a user interface for inputting a source code by a program developer, and includes input means such as a keyboard and a mouse, and display means such as a monitor.

  The program development support device 20 is for improving the efficiency of input of common items among a plurality of batch programs and improving the maintainability of the developed batch processing system when coding a batch program. A usage history storage unit 24 is provided.

  In the present embodiment, for the coding of a batch program, common items between a plurality of batch programs including the batch program are input from the common item storage unit 22 by a specific operation different from the input operation of other source code. It is prescribed.

  For example, for other source codes, the user directly inputs with a keyboard included in the UI 10 as in normal coding. However, for common items stored in the common item storage unit 22, drag & The data is read from the common item storage unit 22 and input by a drop operation.

  In order to read and input the common item from the common item storage unit 22 by drag and drop operation, for example, a list of common items stored in the common item storage unit 22 is expanded on the display screen of the UI 10 and dragged. It is only necessary to be able to input at the cursor position of the batch program being coded by the & drop operation.

  The common item storage unit 22 stores common items referred to by a plurality of batch programs as described above. These common items are created in advance and stored in the common item storage unit 22.

  In a batch processing system, common items that greatly affect the entire system include table input / output items, file input / output items, common functions, parent classes when inheriting classes, common constants, environment variables, and the like.

  As for the creation of the common item, for example, the designer of the batch processing system may create it in advance in the form of a program code and store it in the common item storage unit 22. Or, when using an automatic program generation tool as disclosed in Patent Document 1, based on the specification description created by the designer of the batch processing system, the automatic program generation tool performs coding of individual batch programs. It may be created before and stored in the common item storage unit 22.

  The usage history storage unit 24 records the reference history of common items at the time of coding for each batch program. For example, when the batch program A is coded, when the common item A1 stored in the common item storage unit 22 is input three times by a specific operation (drag and drop operation in the present embodiment), the usage history is stored. For the batch program A, the unit 24 records, for example, the content of “common item A1, 3 times” as the usage history.

  As described above, in the program development system 1 according to the present embodiment, the program development support apparatus 20 stores the common items created in advance and performs a specific operation at the time of coding the batch program for each batch program. According to the history of (drag and drop operation), the reference history of each common item is obtained and recorded.

  First, common items referenced by multiple programs are managed centrally independently of the source code, displayed on the screen, and input by specific operations without manual input, eliminating user input errors Can do. In addition, since there is no variation in the handling of common items for each program, all the source codes are unified and the maintainability of the source codes is increased.

  Moreover, since the reference history of the common items stored in the common item storage unit 22 is recorded for each batch program, the reference history stored in the usage history storage unit 24 is referred to when the program is changed or during impact analysis. By doing so, the usage status of the common items among the plurality of batch programs can be grasped in detail for each program, so that it is possible to reduce user errors such as impact analysis man-hours, correction omissions and omissions. The larger the system, the greater the effectiveness.

  Furthermore, since the common items created in advance are stored, the reference history corresponding to the distribution status of the common items in each batch program is obtained from the history of specific operations specified to be used for inputting the common items. It is simpler and more reliable than the method of Patent Document 2 that acquires and replaces common items by analyzing the source code of the batch program.

<Second Embodiment>
FIG. 2 shows a program design management system 50 according to the second embodiment. The program design management system 50 further embodies the program development system 1 according to the first embodiment, and more strongly supports the development and maintenance of batch programs. Hereinafter, the batch program is also simply referred to as “program”.

  The program design management system 50 can generate a program source code almost automatically based on a specification description (design information described later) created by a user. This function is described in Patent Document 1, for example. Use things. The program design management system 50 can also automatically generate common items based on specifications, definitions, etc. created by the user.

  As shown in FIG. 2, the program design management system 50 includes an impact analysis screen 103, a design repository input / output unit 105, a common item access display output unit 106, a program development screen 104, a design repository input / output unit 105, a source / design document. An output unit 119, a common item definition generation 112, and a matching controller unit 117 are provided. Among these functional blocks, the common item definition 116, the design repository input / output unit 105, and the design repository 118 function as a program development support device.

  The impact analysis screen 103 is a screen for inputting the program change portion 100 at the time of impact analysis.

  The design repository input / output unit 105 extracts, from the design repository 118, a program related to the program change portion 100 input from the impact analysis screen 103 and a corresponding process in the program.

  The common item access display output unit 106 outputs the common resource access table 107, the file access table 108, or the table access table 109 based on the result extracted by the design repository input / output unit 105.

  In the program development screen 104, design information 101, coding information 102, and a common item definition 116 are input at the time of program coding.

  The design repository input / output unit 105 records the design information 101, coding information 102, and common item definition input from the program development screen 104 in the design repository 118 in association with each processing unit.

  The source / design document output unit 119 generates the source code 110 and various design documents 111 based on the design information and coding information extracted from the design repository 118 by the design repository input / output unit 105.

  The common item definition generation 112 generates a common item definition 116 based on the database schema information 113, the file specification 114, and other common resource definition 115.

  The matching controller unit 117 reflects the changed data in the design repository 118 when the common item definition 116 is changed.

  The program design management system 50 according to the present embodiment mainly adds the following four functions to the program automatic generation system described in Patent Document 1.

<First function: Input common items>
A function for inputting common items from the common item definition 116 to the program development screen 104.

<Second function: linking common items>
A function of associating the design information 101 and coding information 102 input on the program development screen 104 with the design repository input / output unit 105 and recording them in the design repository 118.

<Third function: Impact analysis support>
Based on the program change part 100 input on the impact analysis screen 103, the design repository input / output unit 105 extracts a relevant part from the design repository 118, and the common item access table output unit 106 uses the common resource access table 107, A function for creating the file access table 108 and the table access table 109.

<Fourth function: data matching function>
A function of collectively reflecting the changed portions in the design repository 118 by the data matching controller unit 117 when changes are made to the common items.

In the following, description will be given with emphasis on these four functions.
<Input common items>
Regarding "input common items", first, common items (table input / output items, file input / output items, common functions, parent classes when inheriting classes, common constants, environment variables) referenced by multiple programs are selected. By creating a definition file so that it can be centrally managed independently of other logic and inputting from the program development screen 104 by a specific operation (drag and drop), common resources are managed separately from other logic.

  The definition file is recorded as a common item definition 116 in a certain format from the database schema information 113, the file specification 114, and the other common resource definition 115 in the common item definition generation 112 shown in FIG.

  In the program development screen 104, common resource information is extracted from the common item definition 116 and expanded in the memory on the program development screen. FIG. 3 shows a screen image.

  As shown in FIG. 3, the program development screen 104 includes a program flow diagram area 300 that defines a program structure on the left side of the screen, and a common item list area 301 that displays common items on the right side of the screen. When the target common resource is selected from the pull-down list 302 above the common item list area 301, the target item is extracted from the common item definition information saved in the memory and expanded on the list.

  When coding a program, first, the program is divided into processing units (nodes) in the program flow diagram area 300 of FIG. 3, and a program structure is assembled in a tree format using the nodes 304. One node is responsible for one process.

  In the present embodiment, the nodes are divided into three types: input processing nodes, output processing nodes, and free description nodes. When designing a program structure, one of these is used for designing. The free description node absorbs all nodes other than the input processing node and the output processing node.

  For the coding of the contents of each node, an input screen is prepared for each node type. FIG. 4 shows screens 400 to 402 showing those images. These screens are activated as new windows when each node on the program flow diagram area 300 of FIG. 3 is clicked.

  The coding information of the program can only be input from these three screens. Furthermore, with respect to common items, the target item can be dragged and dropped from the items listed on the common item list area 301 in FIG. The rule is developed in the coding area on the windows 400 to 402 in FIG.

  The drag and drop operation image for each node type is as shown in FIGS. By performing such an operation, it is possible to distinguish which part of the information input from the screen is a common item area and to manage it independently independently.

<Linking common items>
Coding information input from the screens 400, 401, and 402 in FIG. 4 is recorded in the design repository in units of nodes.

  In this embodiment, a dedicated area (800 in FIG. 8, 900 in FIG. 9, 1000 in FIG. 10) for recording how the common item is used is provided, and the location where the common item is input Is recorded in the design repository with information that can be specified.

  For example, in the case of a free description node, as shown in FIG. 8, first, in order to identify a common item, a $ mark is added to the head of the common item to distinguish it from other variables, and the common item usage history area is displayed. Record. In that case, a node name is given after the common item ID. In this way, it is possible to pinpoint to which process in the program this common item is called.

  Next, in the input processing node, as in the free description node, a node name is given after the common item, but in the input processing node, as shown in FIG. ).

  Next, as in the case of the input processing node, the output processing node also adds and records information as an output condition and information that can identify the input source and output destination at the time of transcription as shown in FIG. Conventionally, there has been a system that outputs a CRUD table, but the CRUD table can only identify whether there is any operation of CREATE, READ, UPDATE, or DELETE on a table accessed by a program. In the present invention, the CRUD identification is naturally further advanced, and it is possible to specify in more detail the conditions (joining conditions, extraction conditions, sort key conditions, etc.) used in the SQL operation to the table. Therefore, more accurate impact analysis becomes possible.

<Impact analysis support>
The impact analysis support function allows the user to select a common item whose impact range is to be specified from the impact analysis screen 103 in FIG. The range shown) is searched, the one that matches the selected common item ID is extracted, and the result is displayed in a list form on the screen.

When the input / output item of the table is selected, the information shown in FIG. 12 (table access table 109 of FIG. 2) is output. When the input / output item of the file is selected, the information shown in FIG. 13 (FIG. 2) is output. File access table 108) is output. When a common function, common constant, and environment variable are selected, information as shown in FIG. 14 (common resource access table 107 in FIG. 2) is output, and when a parent class is selected, as shown in FIG. Information (common resource access table 107 in FIG. 2) is output.
In this way, the influence range of the common item can be pinpointed accurately and instantaneously.

<Data alignment>
When a change occurs in the common item, the changed part of the database schema information 113, the file specification 114, or the other common resource definition 115 in FIG. After the definition 116 is regenerated, the data matching controller unit 117 collectively changes the relevant part of the design repository.

  However, this function is required only when the common items are changed. When adding or deleting, it is necessary to review the logic. Therefore, it is necessary to manually modify the impact area after specifying the affected area on the impact analysis screen.

  The program design management system 50 according to the present embodiment is a more embodied / functionalized version of the program development system 1, and can exhibit all the effects obtained by the program development system 1.

  Furthermore, since the program design management system 50 according to the present embodiment records and manages the reference history of the common items for each node for each program, the distribution status and the influence range of the common items at the time of impact analysis. Can be grasped more accurately.

  In addition, since common items referenced by multiple programs are managed centrally independently of the source code, the program can be reflected in the design repository in a batch by using the function to align common item data when changing common items. Correction man-hours and omissions can be reduced.

  The present invention has been described above based on the embodiment. The embodiment is an exemplification, and various modifications, increases / decreases, and combinations may be made to the above-described embodiments without departing from the gist of the present invention. It will be understood by those skilled in the art that modifications in which these changes, increases / decreases, and combinations are also within the scope of the present invention.

  For example, not only source code but also design information, when creating design information corresponding to each of a plurality of programs at the time of creation, common items of these design information are created and stored in advance, If input is performed by a specific operation (for example, drag and drop operation) different from the input operation of other items, the usage history of common items in the design information can be recorded in the design repository in the same manner, An advantageous effect can also be obtained for impact analysis on design information.

  The technology according to the present invention can be used when developing any batch processing system using a database or a file system regardless of the type of business, and the effect becomes more remarkable as the number of batch programs becomes larger and the system becomes larger. is there.

1 Program Development System 10 UI (User Interface)
20 Program Development Support Device 22 Common Item Storage Unit 24 Usage History Storage Unit 50 Program Design Management System 100 Program Change Location 101 Design Information 102 Coding Information 103 Impact Analysis Screen 104 Program Development Screen 105 Design Repository Input / Output Unit 106 Common Item Access Display Output Part 107 Common resource access table 108 File access table 109 Table access table 110 Source code 111 Design document 112 Common item definition generation 113 Database schema information 114 File specification 115 Other common resource definition document 116 Common item definition 117 Consistency controller unit 118 Design repository 119 Source / design document output section 300 Program flow diagram area 301 Common item list area 302 Pull down Strike 400 free descriptions node of the input screen 401 input processing node of the input screen 402 input screen 800 reference history for area 900 reference history for Area 1000 reference history for Area 1100 searched for the output processing node

Claims (7)

A common item storage unit for storing common items created in advance and referenced by a plurality of programs;
For each of the programs, a usage history management unit that records a reference history of the common item,
The common item is defined to be input from the common subject storage unit by a specific operation different from an input operation of another code when coding the program,
The usage history management unit obtains the reference history of the program from the history of the specific operation at the time of coding the program.
Program development support device. Each of the programs is divided and coded for each node of the processing unit,
The usage history management unit records, for each of the programs, the reference history for each node constituting the program.
The program development support apparatus according to claim 1. When any one of the common items is specified during impact analysis, the program further includes an impact analysis support unit that displays the reference history corresponding to the common item for each program.
The program development support apparatus according to claim 1 or 2. A common device that is created in advance and is referenced by a plurality of programs is stored,
For each of the programs, the step of recording and managing the reference history of the common item,
The common item is defined to be input from the storage device by a specific operation different from an input operation of another code at the time of coding the program,
The reference history of each of the programs is obtained from the history of the specific operation at the time of coding the program.
Program development support method. Each of the programs is divided and coded for each node of the processing unit,
For each of the programs, the reference history is recorded for each node constituting the program.
The program development support method according to claim 4. When any of the common items is specified during impact analysis, the reference history corresponding to the common item is displayed for each program.
6. The program development support method according to claim 4 or 5.   A program that causes a computer to execute the program development support method according to any one of claims 4 to 6.

Images