Information processing device, information processing method, and program

Abstract

We provide an information processing device, an information processing method, and a program that intuitively create prototypes of customer-desired applications. [Solution] The application generation method includes: receiving input for an I / O definition screen that defines items to be displayed on the application screen; receiving definitions for event display screens that correspond to action events of each item defined on the I / O definition screen; receiving data for data items to be displayed on the defined event display screens; and generating a prototype application in which the I / O definition screen, event display screen, and the display of data for data items displayed on the event display screens are operated by the action events.

Description

Technical Field

[0001] The present invention relates to an information processing apparatus, an information processing method, and a program for customizing an application.

Background Art

[0002] When creating an application for a customer, first understanding the customer's needs and then creating the application can reduce rework and improve development efficiency.

[0003] In particular, different from internal logic, the screen and operation procedures, etc., operating as the user desires can enhance customer satisfaction.

[0004] Patent Document 1 solves the above problems by listening to the user's needs, determining requirements according to the needs, and simultaneously generating and completing the source code of an application program that can be used for an actual machine on the spot.

Prior Art Documents

Patent Documents

[0005]

Patent Document 1

Summary of the Invention

Problems to be Solved by the Invention

[0006] However, in the case of the above invention, in order to "generate the source code of an application that can be an actual machine" desired by the customer, a "rule table included in the mock-up file" is required. To create a rule table, certain skills and knowledge are also required for salespersons or business users (customer decision-makers) who make proposals to the customer, etc.

[0007] Therefore, it can be difficult for business users to create mock-up applications that meet customer needs, or for sales representatives to create mock-up applications during customer meetings.

[0008] The present invention aims to enable the above-mentioned users to intuitively create prototypes of applications desired by customers. [Means for solving the problem]

[0009] The present invention relates to an information processing device for generating applications, comprising: an IO definition means for receiving input for an IO definition screen that defines items to be displayed on the application screen; an event display screen definition means for receiving definitions for event display screens to be displayed in response to action events of each item defined on the IO definition screen; a display screen data receiving means for receiving data of data items to be displayed on the event display screen defined by the event display screen definition means; and an application generation means for generating a prototype application in which the IO definition screen, the event display screen, and the display of data of data items displayed on the event display screen are operated by the action events. [Effects of the Invention]

[0010] According to the present invention, sales representatives and business users who make proposals to customers can intuitively create prototypes of applications desired by customers. [Brief explanation of the drawing]

[0011] [Figure 1] This is a system configuration diagram showing an example of the configuration of a program development device, application server, database server, and application client according to the present invention. [Figure 2]This block diagram shows examples of hardware configurations applicable to the program development device, application server, database server, and application client according to the present invention. [Figure 3] A diagram showing an example of a software configuration in an embodiment of the present invention. [Figure 4] This figure shows an example of the functional configuration of the first program development device in an embodiment of the present invention. [Figure 5] This figure shows an example of a flowchart for generating a prototype application according to an embodiment of the present invention. [Figure 6] This figure shows an example of a flowchart for screen definition input reception processing according to an embodiment of the present invention. [Figure 7] This figure shows an example of a flowchart for the prototype data input reception process according to an embodiment of the present invention. [Figure 8] This figure shows an example of a flowchart for the prototype application source code generation process according to an embodiment of the present invention. [Figure 9] This figure shows an example of a flowchart of the process during execution of a prototype application according to an embodiment of the present invention. [Figure 10] This figure shows an example of a screen image displayed in the output unit 210 according to an embodiment of the present invention. [Figure 11] This figure shows an example of a screen image displayed in the output unit 210 according to an embodiment of the present invention. [Figure 12] This figure shows an example of a screen image displayed in the output unit 210 according to an embodiment of the present invention. [Figure 13] This figure shows an example of a screen image displayed in the output unit 210 according to an embodiment of the present invention. [Figure 14] This figure shows an example of a screen image displayed in the output unit 210 according to an embodiment of the present invention. [Figure 15] This figure shows an example of a screen image displayed in the output unit 210 according to an embodiment of the present invention. [Figure 16]FIG. is an example of a screen image displayed on the output unit 210 according to an embodiment of the present invention. [Figure 17] FIG. is an example of a screen image displayed on the output unit 210 according to an embodiment of the present invention. [Figure 18] FIG. is an example of a screen image displayed on the output unit 210 according to an embodiment of the present invention. [Figure 19] FIG. is an example of a screen image displayed on the output unit 210 according to an embodiment of the present invention. [Figure 20] FIG. is an example of a screen image displayed on the output unit 210 according to an embodiment of the present invention. [Figure 21] FIG. is an example of a screen definition 402 according to an embodiment of the present invention. [Figure 22] FIG. is an example of a screen definition 402 according to an embodiment of the present invention. [Figure 23] FIG. is an example of the functional configuration of a second program development apparatus according to an embodiment of the present invention. [Figure 24] FIG. is an example of a flowchart of data sample registration processing according to an embodiment of the present invention. [Figure 25] FIG. is an example of a flowchart of prototype data automatic generation processing according to an embodiment of the present invention. [Figure 26] FIG. is an example of a flowchart of prototype application generation according to an embodiment of the present invention. [Figure 27] FIG. is an example of a screen image displayed on the output unit 210 according to an embodiment of the present invention. [Figure 28] FIG. is an example of data in the prototype data sample management main body 471 according to an embodiment of the present invention. [Figure 29] FIG. is an example of data in the synonym management unit 472 according to an embodiment of the present invention. [Figure 30] FIG. is an example of prototype data 443 according to an embodiment of the present invention.

Embodiments of the Invention

[0012] Embodiments of the present invention will be described in detail below with reference to the drawings. <First Embodiment> Figure 1 is a system (information processing system) configuration diagram showing an example of the configuration of a program development device (information processing device operated by a developer to generate a web application), application server, database server, and application client related to the present invention.

[0013] The program development device 101 defines screen layouts and database search instructions according to the developer's instructions. The program development device 101 also generates programs and applications.

[0014] In this embodiment, the application generated by the program development device 101 is a web application, but it is not limited to this. It may also be an application that does not utilize web technology for communication, such as an application that runs on an information processing device such as a mobile phone, smartphone, or tablet, or embedded software.

[0015] The application server 102 executes applications developed on the program development device 101. It can also operate in connection with the database server 103.

[0016] The database server 103 is a database used by the developed application, and in this invention, it may also be used during development for operational verification, etc. For example, for use by developers, the database server 103 may be configured on the same device as the program development device 101 and the application server 102, or it may be located within a network 105 such as a LAN.

[0017] The application client 104 (information processing device) is an end-user input terminal that operates the application program developed on the program development device 101 in cooperation with the application server 102. This application client 104 may also be an information processing device such as a mobile terminal.

[0018] Furthermore, the program development device 101, application server 102, database server 103, and application client 104 may be located on the internet, such as in the cloud, or several information processing devices may be housed in a single enclosure.

[0019] Figure 2 is a block diagram showing an example of hardware configurations applicable to the program development device 101, application server 102, database server 103, and application client 104 according to the present invention.

[0020] In Figure 2, the CPU 201 comprehensively controls each device connected to the system bus 204.

[0021] Furthermore, the ROM 203 or external memory 211 stores the operating system (OS), which is the control program for the CPU 201, as well as programs for realizing various functions of the information processing devices, such as servers, clients, and other devices, as described later.

[0022] RAM202 functions as the main memory, work area, and temporary storage area for CPU201.

[0023] The input controller 205 controls the input from the input unit 209. In an information processing device, the input unit 209 may include a keyboard, a pointing device such as a mouse, or a touch panel.

[0024] Furthermore, if the input unit 209 is a touch panel, the user can give various instructions by pressing (touching with a finger, etc.) the icons, cursors, or buttons displayed on the touch panel.

[0025] Furthermore, the touch panel may be a multi-touch screen or other touch panel capable of detecting the positions of multiple fingers touching it.

[0026] The output controller 206 controls the display of the output unit 210. Examples of the output unit 210 include CRTs and liquid crystal displays. It also includes the display of a notebook computer integrated with the main unit. Furthermore, a projector may also be used.

[0027] The external memory controller 207 controls access to the external memory 211, which stores boot programs, various applications, font data, user files, editing files, printer drivers, etc. The external memory 211 stores various tables and parameters for realizing various functions of each server, client, device, etc. Examples of this external memory 211 include hard disks (HDs), flexible disks (FDs), CompactFlash® cards connected to PCMCIA card slots via adapters, SmartMedia, etc.

[0028] The CPU 201 enables display on the output unit 210 by, for example, performing outline font expansion (rasterization) processing in the display information area of ​​RAM 202. The CPU 201 also enables user input via a mouse cursor (not shown) on the output unit 210.

[0029] The communication interface controller 208 performs communication control processing with external devices via the network. For example, it can perform communication using TCP / IP.

[0030] The program 212 for realizing the present invention is stored in external memory 211 and is executed by the CPU 201 when loaded into RAM 202 as needed.

[0031] Figure 3 is an example of a block diagram showing the software configuration of an embodiment of the present invention.

[0032] The program development device 101 includes the following functional units.

[0033] The I / O definition reception unit 301 receives I / O definition screens from the user, including the arrangement of screens and items (input / output items) to be displayed in the application.

[0034] The event display screen definition unit 302 receives from the user an event display screen that will be displayed in response to an action event on the IO definition screen.

[0035] The display screen data receiving unit 303 accepts input data to be displayed in the prototype application for items (input / output items) displayed on the event display screen.

[0036] The application generation unit 304 generates a prototype application that controls the input data displayed on the I / O definition screen, event display screen, and prototype application so that it operates in response to action events.

[0037] The action event data definition unit 305 defines the input data displayed in the prototype application as an action event.

[0038] The item attribute acquisition unit 306 acquires item names, string type information, and other information defined on the IO definition screen.

[0039] The prototype data storage unit 307 stores prototype data samples (data that serves as a sample for prototype data).

[0040] The prototype data acquisition unit 308 extracts data from the prototype data sample.

[0041] The prototype data selection reception unit 309 obtains the user's selection from multiple prototype data samples using a dropdown list or the like.

[0042] The item name matching unit 310 performs a name matching function, holding synonym data corresponding to multiple item names.

[0043] The display count reception unit 311 receives from the user how many items to display in the list when generating a prototype application that displays a list.

[0044] Figure 4 is a diagram showing the configuration of the program development device 101, the application server 102, and the application client 104.

[0045] The program development device 101 includes a repository definition unit 400, a prototype application generation unit 410, and a repository definition editor unit 420. The prototype application of this invention differs from applications that search for data from a database or create diagrams from calculated data results, as in a production environment. Instead, it displays pre-set values ​​and pre-drawn diagrams, and mimics screen transitions and display changes in the manner of an actual application, serving as a mock-up application.

[0046] Application server 102 corresponds to application server 430 in Figure 4, and application client 104 is equipped with a web browser 450.

[0047] The program development device 101 generates a prototype application 440 using the prototype generation unit 410. In this invention, the term "developer" refers not only to contract developers of applications, but also to a wide range of users of the program development device 101, such as business users and sales representatives.

[0048] The repository definition section 400 stores the application definition 401, screen definition 402, screen component definition 403, screen transition definition 404, actions 405 associated with screen component definition 402, and prototype data 406 associated with action 405. Prototype data refers to the data displayed on the application screen when the prototype application is executed, and does not involve searching for data from a database or creating diagrams from calculated data results as in the production environment, but rather refers to values ​​and diagrams that have been pre-set by the developer. These definitions 401 to 406 are input and configured or placed by the developer via the application development tool.

[0049] Application definition 401 holds the settings for the entire application that the developer is developing.

[0050] The screen definition 402 holds information on various screen component definitions 403 and screen transition definitions 404 that are placed on each screen included in the application. The screen definition 402 also includes information on actions 405 set for each component and prototype data 406 associated with actions 405.

[0051] The prototype application generation unit 410 analyzes the repository definition unit 400 set by the developer and generates a prototype application. After generating the prototype application, it starts the application server 430. When the launched prototype application is accessed from the web browser 450 of the application client 104, it displays the screen of the generated prototype application.

[0052] The repository definition analysis unit 411 analyzes the repository definition unit 400 set by the developer.

[0053] The prototype code generation unit 412 generates source code for the prototype application according to the analysis results of the repository definition analysis unit 411.

[0054] The source code compilation unit 413 compiles the source code generated by the prototype code generation unit 412 and deploys it to the application server 430.

[0055] The repository definition editor section 420 is an example of a procedure for a user to configure the repository definition 400. The repository definition editor section 420 includes the screen definition editor section 421, the screen property editor section 422, the parts palette section 423, the action selection section 424, and the prototype data input section 425.

[0056] The screen definition editor section 421 is a graphical editor that allows developers to intuitively create their desired screen layouts.

[0057] The screen property editor section 422 is an editor that allows developers to set properties for each screen component they have placed.

[0058] The parts palette section 423 is a list of parts (items) that allows developers to place desired screen parts on the screen by dragging and dropping.

[0059] The action selection section 424 is a list of actions (action events) for which the developer can select the action to which to set the prototype data 406.

[0060] The prototype data input unit 425 is a graphical editor for intuitively setting prototype data 406 associated with a specific action 405.

[0061] The application server 430 is a device for executing the prototype application 440 generated by the prototype application generation unit 410.

[0062] The prototype application 440 is an application generated by the prototype application generation unit 410. The prototype application 440 is a mock-up application that allows developers to easily check the display content and operation of the application generated by the program development device 101. The prototype application 440 includes a screen module 441, an action control module 442, and prototype data 443.

[0063] The screen module 441 is a module within the prototype application 440 that has user interface functionality.

[0064] The action control module 442 receives user action execution requests from the screen module 441 and controls the operations associated with those actions.

[0065] Prototype data 443 is data that is read by the action control module 442 and displayed on the screen module 441.

[0066] Although not shown in the diagram, the system also includes an application code generation unit that generates actual working application code, not just a prototype application. The application code generation unit, using the repository definition analysis unit 411, reads and analyzes the application definition 401, screen definition 402, separately defined database definition, data model definition, and business process definition from the repository definition unit 400. The web application code generation unit uses the code generation rules stored in external memory 211 and the content analyzed by the repository definition analysis unit 411 to generate a web application module including compiled Java® code and HTML / JSP / JavaScript® via the source code compilation unit 413.

[0067] Figure 5 shows an example flowchart for generating a prototype application for a web application. Note that each step in the flowchart below is executed by CPU 201 of each device.

[0068] The flowchart in Figure 5 shows the processing flow initiated by the program development device 101 when a developer attempts to generate a prototype application.

[0069] First, in step S501, the program development device 101 receives screen definition input. Details of the process in step S501 will be described later with reference to Figure 6.

[0070] Next, in step S502, the program development device 101 determines whether there has been a request for input of prototype data 443. Specifically, it determines whether 1201 and 1202 in Figure 12, or 1203 and 1301 in Figure 13, which are examples of the action selection unit 424, have been pressed.

[0071] Here, prototype data 443 refers to data that developers display on the screen to check the display content and operation of the prototype application 440. The screen on which the data is displayed may be a web browser 450 or a screen definition editor.

[0072] The action control module 442 controls which prototype data is displayed and at what timing during the execution of the prototype application 440, from among multiple prototype data sets configured by the developer. The action control module 442 also controls the actions associated with each action of the components placed on the screen. In other words, prototype data is linked to actions (action events).

[0073] The program development device 101 accepts the press in order to have the developer specify which action the prototype data they are about to input is associated with.

[0074] If it is determined in step S502 that a request for prototype data input has been received, the process proceeds to step S503.

[0075] On the other hand, if there is no request for prototype data input in step S502, the process proceeds to step S504.

[0076] An example of the action selection section when 1201 is pressed is shown in 1202. Similarly, an example of the action selection section when 1203 is pressed is shown in 1301. In the example in 1301, a list of actions included in the currently displayed screen definition is shown, but a list of actions included in the application definition may also be displayed.

[0077] When the process moves to step S503, the program development device 101 receives prototype data input from the user. Details of the process in step S503 will be described later with reference to Figure 7. After that, the process moves to step S504.

[0078] In step S504, the program development device 101 determines whether a screen definition save request has been made. If it determines that a screen definition save request has been made, it proceeds to step S505; otherwise, it proceeds to step S506.

[0079] When the process moves to step S505, the program development device 101 saves the screen definition to the repository definition unit 400. Then, the process moves to step S506.

[0080] When the process transitions to step S506, the program development device 101 determines whether a prototype generation request has been made. If it determines that a prototype generation request has been made, the process transitions to step S507. On the other hand, if there is no prototype generation request, the process transitions to step S501.

[0081] When the process moves to step S507, the program development device 101 generates the source code for the prototype application. Details of the process in step S507 will be described later with reference to Figure 7.

[0082] Next, in step S508, the program development device 101 compiles the source code generated in step S507.

[0083] In step S509, the program development device 101 deploys the prototype application compiled in step S508 to the application server 430.

[0084] From here on, the explanation will be based on an example where the program development device 101, application server 102, and application client 104 are all run on the same information processing device. However, if each is run on a separate information processing device, each information processing device will launch and execute its respective application (such as a prototype application or a web browser).

[0085] In step S510, the program development device 101 starts the prototype application deployed on the application server 430.

[0086] In step S511, the program development device 101 launches a web browser and begins accessing the URL of the prototype application.

[0087] This concludes the explanation of Figure 5. The subsequent processes will be described later, referring to Figure 9.

[0088] Next, the details of the process in step S501 will be explained with reference to Figure 6.

[0089] Figure 6 shows an example of a flowchart for receiving input for the screen definition of a web application. Note that each step in the following flowchart is executed by the CPU 201 of each device.

[0090] The flowchart in Figure 6 shows the sequence of processes that begin when the process transitions to step S501 in the flowchart in Figure 5.

[0091] First, in step S601, the program development device 101 accepts the placement of screen components by the developer. Specifically, it accepts the placement of components by drag-and-drop 1003 from 1001 in Figure 10, which is an example of the component palette unit 423, to 1002, which is an example of the screen definition editor unit 421. Figure 10 shows an example of dragging and dropping a button component from the component palette unit to the screen definition editor unit. The method of placing screen components is not limited to drag-and-drop from the component palette unit 423 to the screen definition editor unit 421; it may also be by moving already placed components or by copying and pasting already placed components. Furthermore, it may be possible to delete components that have been placed once.

[0092] In the case of Figure 10, the image shows a screen layout with two text input fields (an ID input field and a name input field) and a registration button for registering the ID and name, as shown in 1004.

[0093] Next, in step S602, the program development device 101 determines whether a component containing an action event has been placed. If it determines that a component containing an action event has been placed, it proceeds to step S603; otherwise, it proceeds to step S604.

[0094] When the process transitions to step S603, the program development device 101 registers the actions set for the component that includes the action event. Specifically, it registers the action if the component has an action called onClick in its source code. In Figure 21, which is an example of screen definition 402, definition 2102 of “actions” corresponding to the production environment and definition 2103 of “examples” corresponding to the prototype application are written out. In the example in Figure 21, the data storage format is a JSON file as an example of the implementation method, but the data storage format may be a file in another format or a database. After that, the process transitions to step S604.

[0095] Next, in step S604, the program development device 101 determines whether a property input request has been made. Specifically, it determines whether button 1101 in Figure 11, which is an example of a property input request button for a selected component, has been pressed.

[0096] If it is determined that a property input request has been received, the process proceeds to step S605. If no property input request has been received, the screen definition input acceptance process ends.

[0097] When the process transitions to step S605, the program development device 101 accepts input from the developer regarding properties for a screen component. Specifically, it displays 1102 in Figure 11, which is an example of the screen property editor unit 422, and accepts input for setting the properties of the screen component. In the example in Figure 11, the screen property editor unit 422 is displayed near the component to enable intuitive operation by the developer, but a specific area within the screen may be reserved as the screen property editor unit 422. Alternatively, the screen property editor unit 422 may be displayed as a modal dialog.

[0098] This concludes the explanation of Figure 6.

[0099] Next, the details of the process in step S503 will be explained with reference to Figure 7.

[0100] Figure 7 shows an example of a flowchart for receiving input for prototype data to be displayed on the screen when generating a prototype application for a web application. Note that each step in the following flowchart is executed by the CPU 201 of each device.

[0101] The flowchart in Figure 7 shows the sequence of processes that begin when the process transitions to step S503 in the flowchart in Figure 5.

[0102] First, in step S701, the program development device 101 reads the settings for the action items specified by the developer in step S502 of Figure 5. Specifically, it performs the following two actions. First, it reads 2101 in Figure 21, which is an example of 1004 in Figure 10, which is an example of the screen component definition 403 of the screen component selected by the developer. The data for 2101 is assumed to have been input from 1102 in Figure 11 in step S605 of the flowchart in Figure 6. Next, it reads the definition 2102 of “actions” corresponding to the production environment of the screen component selected by the developer, and the definition 2103 of “examples” corresponding to the prototype application.

[0103] Next, in step S702, the program development device 101 determines whether the setting of the action item read in step S701 involves a screen transition. Specifically, it determines whether a value is set in the "nextUi" property (next screen property in 1102), which is an example of a screen transition definition 404 of 2101, which is an example of a screen component definition 403. In this embodiment, the program development device 101 stores the screen transition definition 404 in the screen component definition 403, but it may also store it in the action definition 405.

[0104] If it is determined that the settings of the action item read in step S701 involve a screen transition, the process proceeds to step S703. If the settings of the action item read in step S701 do not involve a screen transition, the process proceeds to step S704.

[0105] When the program transitions to step S703, the program development device 101 displays the destination screen for the screen transition associated with the setting of the action item read in step S701. Specifically, it displays 1300 in Figure 13, which is the screen set in "nextUi" of 2101. Note that the destination screen 1302 in Figure 13 is also assumed to have been set in advance by user operation (step S601). Note that a screen like 1302 may be displayed by either overwriting the currently displayed screen definition editor unit 421 or by launching a new screen definition editor unit 421.

[0106] The initial display action of the screen image (destination screen) displayed in the screen definition editor section 421 is read and set as the action specified by the developer. After this process, the process transitions to step S704.

[0107] In step S704, the program development device 101 displays on the screen the prototype data already set for the action read in S701 or the action read in S703 (for example, if data like 2201 in Figure 22 is already set, that data).

[0108] Next, in step S705, the program development device 101 accepts the developer's selection of a prototype data display component. Here, a prototype data display component refers to a component that displays data (prototype data) in advance when running a prototype application. Specifically, this is an example of displaying prototype data in a list table like 1302 in Figure 13, which is displayed in the screen definition editor unit 421. In the prototype data display component 1402 in Figure 14, for example, by right-clicking with a mouse (not shown) in the "Name" column and pressing the edit button 1403, the selection of the prototype data display component can be accepted. Also, as shown in 1701 in Figure 17, if the entire list is selected and the table input button 1702 is pressed, the entire list 1701 can be selected as the prototype data display component.

[0109] In the next step, S706, the program development device 101 accepts prototype data input from the developer. Specifically, it displays the prototype data input dialog 1501 shown in Figure 15, which is an example of the prototype data input unit 425. 1501 is the prototype data input dialog displayed when the edit button is pressed in the "Name" field in 1401 in Figure 14. In the case of 1501, the user has entered the prototype data "Noriyuki Tanikawa" in the "Name" field. After the user enters the value, pressing the "OK" button in 1501 determines whether or not to confirm the input in step S707.

[0110] Furthermore, as another example of step S706, an example of the prototype data input unit 425 will be described with reference to Figure 18.

[0111] The prototype data input dialog 1801 in Figure 18 is a screen image that appears when the table input button 1702 in Figure 17 is pressed. The text input field in 1801 accepts input of the data set to be displayed in the list shown in 1701. In the case of 1801, the first row contains "(blank)", "Noriyuki Tanikawa", "(blank)", the second row contains "1001", "Ai Hori", "2019 / 10 / 10", and the third row contains "1002", "Ruriko Yamamura", "2019 / 09 / 18". This data input can also be applied by selecting a CSV file or spreadsheet file from a file selection screen (not shown) that appears when the file selection button 1802 is pressed, and then applying the contents of that file.

[0112] After the user enters a value into the text input field, or after the data is reflected after selecting a file, pressing the "OK" button (1803) determines whether or not the input in step S707 is confirmed.

[0113] In step S706, the system may accept a locale specification in order to switch the prototype data displayed depending on the language. Furthermore, while the system shows a modal dialog as a method for accepting prototype data input, this input method may also involve directly accepting input for the display components selected by the developer in S705, or it may involve batch input via an external file.

[0114] In the next step, S707, the program development device 101 determines whether the developer has confirmed the input of prototype data. Specifically, it determines whether the "OK" button in the prototype data input dialog 1501 in Figure 15 or the "OK" button 1803 in Figure 18 has been pressed. If direct input to a component is received in the input acceptance method in step S706, the determination is made by whether the focus has been removed from that component.

[0115] If it is determined that the prototype data input has been confirmed (the "OK" button is pressed), the process proceeds to step S708. If it is determined that the prototype data input has not been confirmed, the process proceeds to step S706.

[0116] In step S708, the program development device 101 writes the prototype data entered by the developer to the screen definition 402. Specifically, it writes it to 2201, which is an example of prototype data 406 linked to action 405 in the screen definition 402.

[0117] However, with this method, it is not possible to change the data displayed on the screen after the transition by the action that is executed. This is because the prototype data is stored in the initial display action of the screen after the transition. However, by storing the prototype data to be displayed on the screen after the transition on the side of the action that is executed, it may be possible to change the data displayed on the screen after the transition by the action that is executed. Specifically, by storing the objects under "onLoad" in 2201 under "onClick" in 2103, the original button that transitions to the screen (for example, the "Register" button 1003 located at 1000 in Figure 10) may be given the data to be displayed on the screen after the transition.

[0118] In this way, by displaying screen images showing prototype data and transitioning between screens for each action event within the prototype application, it is possible to grasp how the application will function as a mockup before actually creating a working application (for example, searching from a database or creating diagrams from retrieved data). This concludes the explanation of Figure 7.

[0119] Next, the details of the process in step S507 will be explained with reference to Figure 8.

[0120] Figure 8 is an example flowchart illustrating the process of generating source code for a prototype web application. Note that each step in the following flowchart is executed by CPU 201 of each device.

[0121] The flowchart in Figure 8 shows the sequence of processes that begin when the process transitions to step S507 in the flowchart in Figure 5.

[0122] First, in step S801, the program development device 101 reads the application definition 401 specified by the developer from the repository definition unit 400. The repository definition analysis unit 411 analyzes the read definition and stores it in the ROM 203, and the analyzed definition is referenced as appropriate by each generation unit.

[0123] In step S802, the program development device 101 reads the screen definition 402 included in the application definition 401 read in step S801 from the repository definition unit 400.

[0124] In step S803, the program development device 101 reads the screen component definition 403 included in the screen definition 402 read in step S802 from the repository definition unit 400.

[0125] In step S804, the program development device 101 reads the screen transition definition 404 included in the screen definition 402 read in step S802 from the repository definition unit 400.

[0126] In step S805, the program development device 101 reads the prototype data 406 contained in the screen definition 402 read in step S802 from the repository definition unit 400. The data read here in the screen definition 402 is the "examples" data in Figures 21 and 22, which corresponds to the prototype data, and the "actions" data, i.e., the data for the production environment, is not used. Having these two sets of data makes it possible to create screen definitions for both prototype data and the production environment in a common way, and application screens created for mockups can be defined directly as application screens.

[0127] In step S806, the program development device 101 generates the source code for the prototype application using the prototype code generation unit 412 based on the information read in steps S801 to S806.

[0128] This concludes the explanation of Figure 8.

[0129] Next, a flowchart illustrating the operation of the prototype application 440 on the application server 102 after the prototype application generation process shown in Figure 5 will be explained with reference to Figure 9.

[0130] Figure 9 is an example flowchart showing an example of the operation of the prototype application 440 deployed in step S509 of Figure 5. Note that each step in the following flowchart is executed by the CPU 201 of the application server 102 (430).

[0131] The flowchart in Figure 9 shows the process flow that begins when the prototype application 440 is launched after being deployed to the application server 430, and when a user accesses it from the web browser 450 of the application client 104.

[0132] In step S901, the application server 430 first reads the browser's locale information. This locale information allows the display language of the prototype data to be switched.

[0133] In step S902, the application server 430 receives an action execution request from the user.

[0134] In step S903, the application server 430 determines whether a user has requested an action. Specifically, it determines whether 1901 in Figure 19, which is an example of a generated screen component, was pressed. At this time, since the user's purpose is to confirm the actions to reproduce the image of using the application, it is not necessarily required for the user to enter anything in the "ID" input field or the "Name" input field 1902.

[0135] If it is determined in step S903 that an action execution request has been made (1901 was pressed), the process proceeds to step S904. If there is no action execution request from the user, the process returns to step S902.

[0136] When the process transitions to step S904, the application server 430 reads the settings for the requested action. For example, in the case of the action settings for 2200 in Figure 22, the process under "examples" in 2201 is executed. In the production environment, the process under "actions" in 2202 is executed, but this process under "actions" is coded by the developers to work more specifically after the mockup application is completed.

[0137] In step S905, the application server 430 determines whether the action read in step S904 involves a screen transition. If it determines that the action involves a screen transition, it proceeds to step S906; otherwise, it proceeds to step S907.

[0138] When the process transitions to step S906, the application server 430 displays the destination screen set for the action read in step S904. As an example of a specific destination screen, Figure 20 shows 2000, which is the list of registered users.

[0139] In step S907, the application server 430 displays the prototype data set for the action read in step S904. Figure 20 shows 2001 as an example of specific prototype data. 2001 is an example of data that reflects the prototype data of 2201 in Figure 22.

[0140] Furthermore, the display language of the prototype data set for the action loaded in step S904 may be set according to the browser locale information loaded in step S901. Alternatively, a default locale may be set in case no prototype data exists for the relevant locale information. Additionally, the system may accept language selection from the user via screen components and display the prototype data accordingly. This locale-based display language support for prototype data makes it easier for multinational sales representatives and business users to understand how the system works.

[0141] This concludes the explanation of Figure 9.

[0142] Through the processes described above, sales representatives and business users who make proposals to customers can intuitively create prototypes of the applications desired by the customer.

[0143] Furthermore, since this invention relates to a program development device that has the function of generating a production application, the prototype application generated by the present invention will have the same appearance and screen transitions as the production application.

[0144] In other words, sales representatives can easily modify input / output items and transition screens on the same screens as the production application, and the modified I / O definition screens and transition screens are reflected in the production application, which developers can then use directly when generating the production application later. This prevents discrepancies between developers and sales representatives or business users, and has the effect of reducing the need for rework during development.

[0145] <Second Embodiment> In the first embodiment, we described a specification for generating a prototype application by inputting prototype data for the application. In the second embodiment, we will describe a procedure for reducing the effort required for the user to input prototype data.

[0146] Figure 23 is a diagram showing the configuration of the program development device 101, the application server 102, and the application client 104.

[0147] The program development device 101 includes a repository definition unit 400 and a prototype application generation unit 410.

[0148] The program development device 101 generates a prototype application using the prototype application generation unit 410, based on the definitions in the repository definition unit 400 set by the developer developing the application.

[0149] Furthermore, the second embodiment includes a prototype data setting unit 460 and a prototype sample management unit 470.

[0150] A screen definition transmission unit 426 is added to the repository definition editor unit 420.

[0151] The screen definition transmission unit 426 holds UI definition information, including item information to be placed on the application screen. The screen definition transmission unit 426 transmits UI information (such as UI item names and string type information) including item information placed in the screen definition editor unit 422 to the screen definition reception unit 461 in the prototype data setting unit 460.

[0152] The prototype data setting unit 460 includes a screen definition receiving unit 461, an item information extraction unit 462, an item name 463, type information 464, a prototype data acquisition unit 465, and a system overview input unit 466.

[0153] The screen definition receiving unit 461 receives and holds UI information, including the arranged item information, sent from the screen definition transmitting unit 426.

[0154] The item information extraction unit 462 extracts the item name 463 and type information 464 from the received UI information.

[0155] The prototype data acquisition unit 465 uses the item name 463 and type information 464 extracted from the UI information to access the prototype data sample management unit and extract prototype data that matches the item name 463 and type information 464. Then, it passes the extracted prototype data to the prototype data input unit 424 of the repository definition editor unit 420, causing the prototype data to be output to the corresponding item on the application screen.

[0156] The system overview input unit 466 accepts free text input. The received information is passed to the system overview analysis unit 474.

[0157] The prototype data sample management unit 470 includes a prototype data sample management main unit 471, a synonym management unit 472, a system category management unit 473, and a system overview analysis unit 474.

[0158] The prototype data sample management unit 471 performs a search using the item name and type information received from the prototype data acquisition unit 465. If a suitable prototype data is found, it is extracted and passed to the prototype data acquisition unit 465.

[0159] The synonym management unit 472 uses the item names received from the prototype data acquisition unit 465 to search for synonyms of item names not registered in the prototype data sample management main unit 471. Since the synonym management unit 472 can define multiple synonyms, the more synonyms are added, the higher the efficiency of prototype data detection becomes.

[0160] The system category management unit 473 manages prototype data for each system category in the prototype data sample management main unit 471. System categories can be freely added by users, such as default categories. By adding system categories, even if the item names are the same, appropriate prototype data examples can be extracted according to the system category.

[0161] The system overview analysis unit 474 uses the information received from the system overview input unit 466 to perform morphological analysis, divide it into words, and then executes a search in the prototype data sample management main unit 471. This increases the likelihood of extracting examples of prototype data that conform to the system overview.

[0162] This concludes the explanation of Figure 23.

[0163] Next, the processing procedure for reducing the user's input effort for prototype data in the second embodiment will be described with reference to Figures 24 to 26.

[0164] Figure 24 is an example flowchart illustrating the process of registering prototype data samples. Each step in the following flowchart is executed by the CPU 201 of each device.

[0165] The flowchart in Figure 24 is performed after the processing of step S601 in the flowchart in Figure 6. Note that the flowchart in Figure 24 can be performed at any time after the component placement acceptance processing in step S601 and before step S704 in Figure 7.

[0166] First, in step S2401, the program development device 101 receives UI information from the user, including the item name of the component (input / output item) placed in step S601 (for example, "Application Date" as 2702 in the example in Figure 27) and the type information of the characters to be input / output (for example, "yyyymmdd", which is a date type as 2703 in the example in Figure 27). Note that when the component is placed, no specific date or data is entered into each input / output item of the UI definition information as shown in Figure 27.

[0167] In step S2402, the program development device 101 accepts registration of actual data (prototype data sample) that matches the item name and type information. An example of a accepted prototype data sample is explained with reference to Figure 28.

[0168] Figure 28, item 2801, shows an example of a prototype data sample stored in the prototype data sample management unit 471. For example, the "date" data is in the "date type" format, and "20190918" is registered as actual data (prototype data sample). This registered data can be reused in other systems generated later, and there is no limit to the number of data that can be registered, so the number of data can be freely increased. Therefore, the accumulation of this prototype data sample becomes useful data.

[0169] Note that although the registration of this data is described as being done separately from Figure 25, which will be discussed later, initially, the prototype data entered in step S706 of Figure 7 may be registered as prototype data samples. Return to the explanation of the flowchart in Figure 24.

[0170] Next, in step S2403 of Figure 24, the prototype data sample received in step S2402 is stored as a file. The prototype data sample may be stored in a database or by other storage means.

[0171] This concludes the explanation of Figure 24.

[0172] Figure 25 is an example flowchart illustrating the flow of the automatic prototype data generation process. Each step in the following flowchart is executed by the CPU 201 of each device.

[0173] The flowchart in Figure 25 represents the process executed during step S704 in the flowchart in Figure 7. In other words, it is the flowchart that starts before transitioning to the screen where the destination screen is displayed and the user inputs prototype data into each input / output item.

[0174] First, in step S2501, the program development device 101 receives UI definition information, including the arranged item information, using the screen definition receiving unit 461. For example, in the case of the UI definition information in Figure 27, it obtains the screen generation data and UI information (such as UI item names and character type information) in 2701.

[0175] In step S2502, the program development device 101 uses the item information extraction unit 462 to extract the item name 463 and type information 464 (UI information) from the received UI definition information. For example, in Figure 27, it extracts UI information where the item name 2702 is "Application Date" and the type information 2703 is "yyyymmdd".

[0176] In step S2503, the program development device 101 uses the prototype data acquisition unit 465 to access the prototype data sample management unit 470 and extract prototype data. The specific processing in step S2503 will be described later in Figure 26.

[0177] In step S2504, the program development device 101 determines whether there is prototype data that matches the item name and type information extracted in step S2503. If it determines that there is prototype data that matches the item name and type information, it proceeds to step S2505. On the other hand, if there is no prototype data that matches the item name and type information, the automatic prototype data generation process ends, and in step S706 shown in Figure 7, it accepts input from the user.

[0178] When the process transitions to step S2505, the program development device 101 uses the prototype data acquisition unit 465 to transfer the extracted prototype data to the prototype data input unit 425. The program development device 101 then uses the prototype data input unit 425 to register the prototype data in the corresponding fields. An example of registered prototype data will be explained with reference to Figure 30.

[0179] Figure 30 shows an example of prototype data for the data defined in the UI definition information in Figure 27. The fact that prototype data "20190918" is assigned to item names that are different from "dates," such as "Application Date" and "Usage Date," will be explained later in Figure 26.

[0180] The above process significantly reduces the effort required for users to input prototype data into the items displayed when creating a prototype application. This allows sales representatives and business users (customer decision-makers) to easily create prototype applications (mock-up applications that display pre-set values ​​and pre-drawn diagrams, and mimic screen transitions and display changes like an actual application).

[0181] Furthermore, when displaying prototype data in a list (for example, 2000 in Figure 20), the system can accept input from the user for the number of prototype data items to extract, and register the prototype data so that the number of extracted items received can be displayed in a list format. In the case of Figure 20, for example, it can be seen as the result when the user inputs 3 items from a screen that is not shown to extract the prototype data. In this way, a prototype application that displays prototype data in a list can also be automatically generated.

[0182] Additionally, to display data that appears as if it were the result of searching for a common string when displaying a list, you can register the common parts and other parts of the data separately. For example, you can register "Tanaka" and "Yamamoto" as names and "Shiro," "Aya," and "Kakuei" as names separately. When registering and displaying multiple items as prototype data, setting the common part input allows you to register data that has common elements, such as "Tanaka Shiro," "Tanaka Aya," and "Tanaka Kakuei," when displaying a list of three items. In this way, by generating prototype data with common elements, you can create a prototype application where the list display result screen appears as if it were the result of a search (in the previous example, "Tanaka").

[0183] This concludes the explanation of Figure 25.

[0184] Figure 26 is an example flowchart illustrating the process of extracting prototype data from the prototype data sample management unit 470. Each step in the following flowchart is executed by the CPU 201 of each device.

[0185] The flowchart in Figure 26 shows the process executed as a subroutine in step S2503 of the flowchart in Figure 25.

[0186] First, in step S2601, the program development device 101 uses the prototype data sample management main unit 471 to receive item names 463 and type information 464 from the prototype data acquisition unit 465. Specifically, it acquires the UI definition information of the screen displayed in step S703 of Figure 7 and obtains the UI information (item names 463 and type information 464) for each input / output item.

[0187] In step S2602, the program development device 101 uses the synonym management unit 472, which stores the necessary synonyms, to determine if there are any synonyms that can be used to match item name 463. If it determines that there are any suitable synonyms, it proceeds to step S2603; otherwise, it proceeds to step S2604.

[0188] The specific decision in step S2602 will be explained with reference to the example UI definition information 2701 in Figure 27 and the synonym management unit 2901 in Figure 29. 2901 is a synonym dictionary that changes the item name received from the UI definition information to an item name that can be handled by the prototype data sample management main unit by querying the synonym management unit 2901. As an example, suppose the item name "Name" is obtained from the UI definition information. The synonym management unit 472 has registered item names such as "Name," "Applicant," and "Approver" so that the system can recognize them as items similar to "Name." Therefore, even an item other than "Name," such as "Name," can be handled by the prototype data sample management main unit.

[0189] For example, the item name of input / output item 2702 in Figure 27 is "Application Date". To determine if there is a synonym corresponding to the item name "Application Date", refer to 2901 in Figure 29. In 2901, "Application Date" 2903 is registered as a synonym for "Date" 2902, so the prototype data sample with the item name "Application Date" will be obtained from "Date". In other words, this is an example where there was a suitable item name "Date" in the prototype data sample for "Application Date". Return to the explanation of the flowchart in Figure 26.

[0190] When the process transitions to step S2603, the program development device 101 obtains a new item name (in the above case, "Date" 2902) in the prototype data sample for the item name (in the above case, "Application Date" 2702) obtained in step S2601.

[0191] In step S2604, the program development device 101 determines whether there is data in the prototype data sample management unit that matches the type information of the item name or item string obtained in step S2601 or step S2603. If it determines that there is matching data, it proceeds to step S2605. If there are no matching synonyms, it completes the processing of the flowchart in Figure 26 and accepts input from the user in step S706.

[0192] The specific decision in step S2604 will be explained with reference to the example of UI definition information 2701 in Figure 27, the stored data 2801 of the prototype data sample management main unit in Figure 28, and the synonym management unit 2901 in Figure 29.

[0193] For example, the item name of input / output item 2702 in Figure 27 is "Application Date," and a new item name "Date" corresponding to the item name "Application Date" is obtained from 2902 in Figure 29. It is then determined whether "Date" is registered in the stored data 2801 of the prototype data sample management unit in Figure 28 as a prototype data sample that matches the new item name "Date." In the case of Figure 28, "Date" is registered in 2802, so the process proceeds to step S2605. Return to the explanation of the flowchart in Figure 26.

[0194] When the process transitions to step S2605, the program development device 101 extracts "20190918" 2803 as a prototype data sample registered in the item name "Date" 2802, which was matched in step S2604, and stores it as prototype data. Then, it returns to the flowchart in Figure 7 and executes the subsequent processes to generate the prototype application in the flowchart in Figure 8.

[0195] As described above, the program development device 101 generates a prototype application into which the prototype data has been input. An example of the generated prototype application will be explained with reference to Figure 27.

[0196] In Figure 27, for example, the "Application Date" 2702 and "Usage Date" fields are matched with the synonym "Date" 2902 based on the data from the synonym management unit 2901 in Figure 29, and "20190918," which is registered as "Date" 2802 in the prototype data sample in Figure 28, is registered. Similarly, the item names such as "Applicant" and "Destination," "Departure," and "Arrival" in Figure 27 are matched with the item names in the corresponding prototype data samples based on the data from the synonym management unit 2901 in Figure 29, and the prototype data from prototype data sample 2801 is registered. Note that if there are multiple prototype data samples when retrieving prototype data from the same prototype data sample, such as "Departure" and "Arrival," two different prototype data sets may be used. Alternatively, a dropdown list may be displayed in the item fields in Figure 27 (for example, the input / output items for "Departure") to allow the user to select (in the case of Figure 28, selection from "Tokyo Station," "Sengakuji Station," and "Yurakucho Station").

[0197] As described above, an example of the prototype data for the prototype application example shown in Figure 27 is shown in Figure 30. This concludes the explanation of the flowchart in Figure 26.

[0198] As described above, prototype data samples are extracted from the UI information (such as UI item names and string type information) in the UI definition information and registered as prototype data in the input / output items. In other words, a prototype application can be easily generated.

[0199] Furthermore, the inclusion of a synonym management unit 472 allows for the matching of item names, enabling the assignment of prototype data even with a small number of prototype data samples.

[0200] Furthermore, when registering prototype data in list format, you can generate a prototype application with a list of prototype data simply by entering the number of items you want to register.

[0201] Furthermore, when registering prototype data in a list format, by making part of the string common, it is possible to generate a prototype application that looks as if it were a search result.

[0202] As described above, it goes without saying that the object of the present invention can also be achieved by supplying a recording medium containing a program that realizes the functions of the embodiments described above to a system or device, and by having the computer (or CPU or MPU) of that system or device read and execute the program stored on the recording medium.

[0203] In this case, the program read from the recording medium itself realizes the novel function of the present invention, and the recording medium on which that program is recorded constitutes the present invention.

[0204] For recording media used to supply programs, examples include flexible disks, hard disks, optical disks, magneto-optical disks, CD-ROMs, CD-Rs, DVD-ROMs, magnetic tapes, non-volatile memory cards, ROMs, EEPROMs, silicon disks, and the like.

[0205] Furthermore, it goes without saying that the functions of the aforementioned embodiments are realized not only by the computer executing the program it has read, but also by the operating system (OS) running on the computer performing some or all of the actual processing based on the instructions of that program, thereby realizing the functions of the aforementioned embodiments.

[0206] Furthermore, it goes without saying that this also includes cases where, after a program read from a recording medium is written to the memory of a function expansion board inserted into a computer or a function expansion unit connected to a computer, the CPU or other components of the function expansion board or function expansion unit perform some or all of the actual processing based on the instructions of the program code, and the functions of the aforementioned embodiments are realized through that processing.

[0207] Furthermore, the present invention may be applied to a system consisting of multiple devices or to a device consisting of a single device. It goes without saying that the present invention can also be applied when the results are achieved by supplying a program to a system or device. In this case, by reading a recording medium containing a program for achieving the present invention into the system or device, the system or device can enjoy the effects of the present invention.

[0208] The above program may consist of object code, program code executed by an interpreter, script data supplied to the OS (operating system), and other forms.

[0209] Furthermore, by downloading and reading the program for achieving the present invention from a server, database, etc. on a network using a communication program, the system or device can enjoy the effects of the present invention. It should be noted that configurations combining the above-described embodiments and their variations are all included in the present invention. [Explanation of Symbols]

[0210] 101 Program Development Equipment 102 Application Server 103 Database Server 104 Application Clients 105 Network

Claims

1. An information processing device for generating applications, An I / O definition means that accepts input for an I / O definition screen that defines items to be displayed on the application screen, An event display screen definition means that accepts definitions for event display screens to be displayed in response to the action events of each item defined in the aforementioned I / O definition screen, A display screen data receiving means that receives data for data items to be displayed on the event display screen defined by the event display screen definition means, Application generation means for generating a prototype application in which the I / O definition screen, the event display screen, and the display of data for data items displayed on the event display screen are operated by the action event, An information processing device characterized by having the following features.

2. The event display screen defined by the event display screen definition means holds the data received by the display screen data receiving means. The information processing apparatus according to claim 1, characterized in that the prototype application generated by the application generation means displays the data received by the display screen data receiving means on the event display screen.

3. An action event data definition means that causes the data of the data items received by the display screen data receiving means to be defined in the action event, The information processing apparatus according to claim 1 or 2, characterized in that the prototype application generated by the application generation means is displayed on the event display screen using the data defined by the action event data definition means.

4. The information processing apparatus according to claims 1 to 3, characterized in that the definition of the event display screen to be displayed in response to the aforementioned action event has a plurality of definitions.

5. The definition of the event display screen to be displayed in response to the aforementioned action event has definitions for the production environment and for the prototype application. The information processing apparatus according to claims 1 to 4, wherein the application generation means generates a prototype application using the definition of an event display screen for the prototype application.

6. The information processing apparatus according to claims 1 to 5, wherein the display screen data receiving means causes the event display screen to input data for data items displayed on the event display screen.

7. The information processing apparatus according to claims 1 to 6, wherein the display screen data receiving means receives data by specifying a file corresponding to the data of the data items displayed on the event display screen.

8. The aforementioned I / O definition means also defines locale information for the prototype application. The information processing device according to claims 1 to 7, characterized in that the display language of the data items displayed on the event display screen is set based on the locale information.

9. An information processing method in an information processing device that generates applications, The I / O definition process accepts input from an I / O definition screen that defines the items displayed on the application screen, An event display screen definition step that accepts the definition of an event display screen to be displayed in response to the action events of each item defined in the aforementioned I / O definition screen, A display screen data reception step that receives data for data items to be displayed on the event display screen defined in the event display screen definition step, The application generation process generates a prototype application in which the I / O definition screen, the event display screen, and the display of data for data items displayed on the event display screen are operated by the action event. An information processing method characterized by having the following features.

10. A program that runs on an information processing device that generates applications, The information processing device An I / O definition means that accepts input for an I / O definition screen that defines items to be displayed on the application screen, An event display screen definition means that accepts definitions for event display screens to be displayed in response to the action events of each item defined in the aforementioned I / O definition screen, A display screen data receiving means that receives data for data items to be displayed on the event display screen defined by the event display screen definition means, Application generation means for generating a prototype application in which the I / O definition screen, the event display screen, and the display of data for data items displayed on the event display screen are operated by the action event, A program characterized by being operated in this manner.

Images