JPH03116282A - Visual program production method and moving picture production method - Google Patents

Abstract

PURPOSE:To facilitate the production of a program by visualizing a subject which is going to operate the program in its original image. CONSTITUTION:A keyboard 103 is provided together with a display device 101, a scene control program 106 which controls the program production process stored in a main storage 102, and a CPU 105. Then the example value of data is set and this data is displayed on a display 101 as a graphic corresponding to the type of the prepared data. Then a command train inputted by a programmer is stored in the storage 102 as a program. A process corresponding to each command is carried out to a prepared data operation command group. Then the process of each command is displayed as a corresponding moving picture to the prepared data operation command group, and the stored command trains are successively carried out. As a result, a program can be easily produced.

Description

DETAILED DESCRIPTION OF THE INVENTION [Field of Industrial Application] The present invention relates to a program creation method, and particularly to a program creation method suitable for programming in a computer having a bitmap display device capable of displaying graphics.

[Conventional technology]

Conventionally, a method using diagrams such as flowcharts has been used to visualize programs and improve creation efficiency.

Flowcharts make it easier to understand by two-dimensionally illustrating control flows such as conditional branches and repeat loops in a program, but the data handled by the program has not been visualized. On the other hand, there is a method to simplify program creation using icons that visually represent the data and procedures handled by the program,
4-1 (1987), pp. 29-39 (IEEE
Software, Vol. 4. Ncil, pp.
, 29-39).

This kind of visual programming (VisualPro
In Japanese Patent Application No. 62-279215, one of the inventors proposed a method called ``gramming'' in which data to be processed by a program is displayed two-dimensionally as an icon on a display device, and instructions for data manipulation are displayed on the display device. We showed how to create a program by doing this to icons.

It has a data selection instruction that displays data that meets a given selection condition as an icon, and a data manipulation instruction that manipulates the selected data and displays the result as an icon again, making it easy to use with a variety of data processing programs. , it is now possible to create the target data structure while viewing it on a display device.

[Problem to be solved by the invention]

The conventional technology described above visualizes the structure of data handled by a program in two dimensions to facilitate understanding, but the data is related to numerical data such as numerical values or arrays of numerical values. Programs that manipulate numerical data have a wide range of applications, but there are many other important problem areas. For example, when considering artificial intelligence problem-solving programs, they often deal with more concrete and visual data.A simple example of this is the Tower of Hanoi problem, which is often used as a teaching material for programming. Let's think about it.

The Tower of Hanoi problem is that, as shown in Figure 18(a), there are three towers where disks can be placed, and in the initial state, only one tower has multiple disks placed in order from the largest disk to the smallest. When the plates are placed, one disk at a time must be moved from tower to tower, with the condition that no larger disk is placed on top of a given disk. The problem is to move all disks from one tower to another. In the case of this problem, the object of the program's operation is data with a concrete image such as a disk or a tower. In conventional programming languages based on strings of symbols, data such as disks and towers were converted into abstract symbols to create a program to solve this problem. For example, what is shown in FIG. 18(b) is a program that solves the Tower of Hanoi problem using the LISP language, which is a programming language for artificial intelligence. Further, FIG. 18(c) shows the execution result of the program shown in FIG. 18(b). In the program shown in FIG. 18(b), for example, a tower having three disks is realized as an example of numerical data such as [3, 2, 11, and according to this method, even with the above-mentioned conventional technology, the Tower of Hanoi is realized. The problem can be solved. However, the program shown in Figure 18(b) is
This is far from the image shown in a), and is one of the reasons why programming is a difficult task for ordinary non-specialists.

In addition to this artificial intelligence problem, there are many programs that handle visual data, such as finding the shortest path on a diagram. Further, many device control programs issue operational commands to each part of the device, and in this case, the target to be handled is a concrete object such as a component, that is, visual data. The above-mentioned prior art does not give consideration to providing an easier-to-understand program creation method by handling programs that manipulate objects that originally have concrete graphic images as they are.

Further, the above-mentioned conventional technology lacks consideration for visualizing the progress of an operation on an operation target having a concrete image as described above to help the programmer understand the progress status. In other words, the above-mentioned conventional technology displays the result of the operation, but does not display changes in the state during the operation, so there is a problem in that it is difficult to understand what has changed before and after the operation. In other words, in the example of the Tower of Hanoi mentioned above, the operation of moving a disk originally has the image of the disk moving sequentially in space, and in the example of equipment control, a certain mechanism operates and one part moves or moves. There is an image of it rotating. In the prior art described above, these visual elements are not shown to the programmer.

[Means to solve the problem]

In order to achieve the above purpose, a step of setting the inversion of data, a step of displaying the data set with one example value as a figure corresponding to the type of data prepared in advance,
a step of storing the command string input by the programmer as a program;

A step of executing a process corresponding to each command for a group of data manipulation commands prepared in advance, a step for the group of data manipulation commands prepared in advance, and a step of sequentially executing a command string stored as the program. This step is provided with steps.

[Effect]

In the step of setting the data position, a specific position is set for the data. Thereby, the step of displaying the data as a figure can display the data as an image of a concrete object, which was one of the objects of the present invention. For example, example data such as the Tower of Hanoi with two discs is set, so this can be displayed as a concrete figure. By sequentially storing data manipulation commands input by the programmer as a program, visual manipulations on figures are accumulated as a symbol string program. Basic operation commands for data such as numerical data, Tower of Hanoi data, or disk data can be executed by preparing a group of subroutines to be executed in advance, and the execution of these basic operation commands is also prepared in advance. It is also possible to show the progress of subroutine data manipulation in an easy-to-understand manner to the programmer. Even for commands that are not prepared in advance, the execution procedure is defined as a command string stored as the array program mentioned above.
It is possible to create complex programs in a hierarchical manner.

〔Example〕

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

FIG. 1 is a diagram showing the system configuration of the present invention.

As shown in FIG. 1, the system includes a keyboard 103 for inputting commands, a display device 101 that visually displays the program creation process in the form of a moving image, and a scene control program that controls the program creation process stored in the main memory 102. 106, and a CPU 105.

The scene control program 10G includes a subroutine group 107
~112. In what example does the example setting subroutine 107 start program creation in the library 108?
The 6 built-in command execution library 109, which is a subroutine that visualizes data such as numbers and Tower of Hanoi and displays it on a display device, is a collection of multiple subroutines, and each subroutine can perform addition/subtraction of numbers, size comparison, or Tower of Hanoi. The built-in command animation library 110, which is used to execute built-in commands prepared in advance in the system, such as the push operation and ρop operation described below, is also a collection of multiple subroutines, and each subroutine is Create a video of the execution of a built-in command. The user program library generation subroutine 111 is.

A history of inputting data manipulation commands by the user is stored in the user program library 113 as a user program. User program library execution subroutine 1
12, when a user-created program other than the above-mentioned built-in command is called as a command, the corresponding program is extracted from the user program library 113 and executed.

Hereinafter, the program creation method of the present invention will be explained with reference to the drawings, taking as an example the creation of a program to solve the Tower of Hanoi problem.

FIG. 2 is a flowchart showing the operation of the scene control program that controls the entire program creation process.

As shown in FIG. 2, when the scene control program 106 is started, the user first inputs from the keyboard 103 the name of the program to be created.
hanoi' is read (step 201), and the example setting subroutine 107 is called (step 202).

FIG. 3 is a flowchart showing the operation of the example setting subroutine 107.

As shown in FIG. 3, when the example setting subroutine 107 is started, a new scene 1001 (FIGS. 10 to 12) is first displayed on the display device 101, and a checkered floor is drawn as a background (step 301). ). Next, the program storage area 9 corresponding to the first scene 1001 of the hanoi program is stored in the user program library 113.
33 (FIG. 9) is created (step 302). Next, iterative loops 303-30 set example data in the scene.
Enter 9. In the loop, the user first inputs the keyboard 10.
Read the input of the name of the example data from step 3 (step 30
3). Next, if it's a number, t hum l, if it's the Tower of Hanoi,'
A name indicating the data type, such as hanoi', is also read using the keyboard 103 (step 304). Furthermore, XY coordinates with the origin at the lower left corner of the scene are input from the keyboard 103. Read the position information of the data (step 305), and finally read the numerical value if it is a number, or the number of disks on it and the width in the X direction of each disk if it is the Tower of Hanoi, as data values from the keyboard 103 ( Step 306). The inputs read above are stored in the program storage area 933 and displayed as text in the scene 1001 (step 307). For example, when the user sets the number N as the value 1 in the upper left corner of the scene as the first example data, entries 903 and 904 are stored in the program storage area 933 (FIG. 9), and text 1002 is added to the scene 1001. Is displayed. Next, the example setting subroutine 107 sends information regarding the input example data, such as name, type name, position, and value, to the data display library 108 (step 308), and the example data is visualized on the display device 101.

FIG. 4 is a diagram showing the contents of the data display library 108.

As shown in FIG. 4, the data display library 108 is a collection of multiple subroutines. In FIG. 4, the operation of each subroutine is shown by a flowchart.

When the example setting subroutine 107 requests the display of the number N (lower position 1), a brutine 401 for displaying number data is selected from the data display library and executed. The broutine 401 for displaying numerical data first draws a square at the specified position in the scene 1001 (step 402),
Next, display 1 in the square (step 403), and finally display the data name l N l in the upper left of the square (step 403).
Step 404). As a result, scene 1001 has a number N
is visualized as a display 1003, and the blue routine 401 for displaying numerical data ends (step 405).

The setting of one example data (number N on the upper side) is completed, and the example setting subroutine asks the user whether there is any more example data left to be set (step 309).
If the user inputs t Y j from the keyboard 103, the example setting subroutine 107 ends (step 310). If the user inputs t N n , the next example data setting is repeated (steps 303 to 308).

In programming the Tower of Hanoi, three Towers of Hanoi are set as example data. Example data for the Tower of Hanoi is set in the same way as for numbers. That is, entries 905 to 910 are stored in the user program storage area 933, and text 1007 is displayed in scene 1001, and three Towers of Hanoi (names a, b, and Q from the left toward scene 1001) are displayed. ) is scene 100
1 as displays 1004, 1005, and 1006. Since the display method for the Tower of Hanoi (model name is 'hanoi') is quite different from that for numbers (model name 'hu++'), the data display library 108 in Figure 4 is requested to display the Tower of Hanoi data. The processing in this case will be explained.

The data display routine 4<) 9 for the Tower of Hanoi first draws an ellipse as a substrate and a rectangle as a core frame at the designated position (step 410). Next, according to the information on the number and size of the disks given by the user, each disk is displayed on the board while being shifted from the bottom (step 411). The display of the disc is performed by the disc data display broutine 406. The disc data display broutine 406 draws an ellipse with a width equal to the size input by the user from the keyboard 103 when setting the side at the specified position. (Step 407) and ends (Step 408). When the display of all the disks is completed, the Tower of Hanoi data display broutine displays the name of Tower of Hanoi below the board (Step 412) and ends (Step 408). 413)
.

This completes the example settings for scene 1001 (step 3
10). The scene is displayed as shown in FIG.

This scene 1001 shows an example of the Tower of Hanoi problem in which only one disk needs to be moved. In the present invention, a general program can be obtained by solving a problem in a specific example such as scene 1001. In fact, in the case of the Tower of Hanoi problem, there are an example of one disc (scene 1001) and an example of two discs (scene 1301 described later).
, FIGS. 13 to 17), a program capable of moving an arbitrary number of sheets can be obtained in the user program library 113.

In the following, we will first take as an example the case where one disk is moved from a to b, that is, the case where a problem is solved by performing data operations on the scene 1001, and the operations after the example setting of the scene control program 106 (from step 203) I will explain about it.

As shown in FIG. 2, when the calling of the example setting subroutine 107 is completed, the scene control program 106 records the commands inputted by the user from the keyboard 103 in the user program library 113, and executes the commands. A loop (steps 203 to 209) is entered.

Command input from the user is performed using the display 1101 in FIG.
As shown, the command arguments are separated by spaces and the command name is specified at the end.

For example, the command 'N 1 =' is a command to check whether the number N is equal to the constant 1.

When the command is read (step 203), the scene control program 106 calls the user program library generation subroutine 111. FIG. 7 shows the operation of the user program library generation subroutine 111.

As shown in FIG. 7, the user program library generation subroutine 111 first stores the read command in the program storage area 933 (step 701), and then displays the command as text in the scene 1001 (step 7o2). , ends (step 703), that is, the user enters the command 'N1='' on the keyboard 10.
3, the entry 911 in the program storage area 933 corresponding to the scene 1001 in the user program library 113 is stored as shown in FIG. 9, and the text is stored as shown in FIG. 1101 is displayed within the scene 1001. The reason why the commands input by the user are displayed as they are in the scene is to enable the user to easily confirm what kind of program is being generated.

The scene control program 106 next checks whether the input command 1101 is a built-in command (step 205), and if it is a built-in command, the built-in command execution library 206 calls it (step 206) - otherwise, The program library execution subroutine 112 is called (step 208). Command 1101 is a built-in command that compares the magnitude of numbers, and built-in command execution library 109 is called (step 206).

The built-in command execution library 109, as shown in FIG. 5, is a collection of subroutines that execute each command. In the case of command 1101, '=1 command execution subroutine 509 is selected and called. '=1 The command execution subroutine 509 compares N, the first argument of the command, and 1, the second argument (step 510
).

Since the value of N is 1' as set in the example, the two are equal, so success is reported and the process ends (step 511).

In the case of a built-in command, the scene control program 106 next calls the built-in command animation library 110 to animate the command execution on the scene and show it to the user (step 207).

FIG. 6 is a diagram showing the contents of the built-in command animation library 110.6 Built-in command animation library 11
0 is also a set of subroutines corresponding to each command. For command 1101, '=' command animation subroutine 607 is selected and executed. As shown in FIG.

'=' The command animation subroutine 607 flashes and emphasizes the number display only when success is reported as a result of execution by the built-in command execution library 109 (step 608). In the case of command 1101, the execution is successful, so display 1003 flashes to visually notify the user that the comparison results are equal.

When the animation is completed (step 609), it is checked whether all command inputs from the user have been completed (step 209), and if the animation has been completed, the scene creation is completed (step 2).
10) If not, read the next command (step 203) and repeat the following process. The user can check whether all command input has been completed by checking '5uccess' as described below.
The determination is made based on whether the -end d' command is input from the keyboard 103 or not. Command 1101 is ' 5u
Since this is not a ccess-end' command, the scene control program 106 moves on to reading the next command (step 203).

In the case of the scene 1001 in which only one disk is moved, the disk from the Tower of Hanoi 1004 may be first taken out and then placed on the Tower of Hanoi 1005. The user then inputs j apop # as the next command. This command is also used in the program storage area 9, similar to the command 1101 for checking whether the number N indicating the number of sheets to be moved is equal to 1.
33 and is stored in entry 912 in scene 1.
o01 as text 1102 (step 204), the 'pop' command is also a built-in command (that is, the built-in command also has an execution subroutine prepared in the execution library), and the 'pOP' command execution subroutine 519 is called. (
Step 206).

As shown in FIG. 5, when the 'pop' command execution subroutine 519 is called, the command 11 is first executed.
The first argument of 02, the top disk on Tower of Hanoi a, is given a name a1 so that it can be identified from now on (step 520), and then the disk a1 is named Tower of Hanoi. It is deleted from data a (step 521). Then, success of command execution is reported (step 522), and the subroutine is ended (step 523).

Next, the scene control program 106 animates the execution of the command as in the case of the command 1101 (step 207). As shown in FIG. 6, when the (po p j command animation subroutine 613 is called), the first
The disk a1, which was the beginning of the Tower of Hanoi specified by the argument, is
The scene 1101 is moved little by little in the Y direction to a position 811 frames above the core frame length of the Tower of Hanoi a (step 618). Then, redisplay the first argument, Tower of Hanoi a, step 619),
Finish (step 620). In this redisplay, the disk has been deleted from Tower a of Hanoi, so command 11
At the end of the animation in step 02, the scene 1001 is in the display state shown in FIG.

Since command 1102 is also not an end command (step 209), the scene control program 106 reads the next command (step 203).

As shown in Figure 11, the scene 1001 is a state in which a disk has been taken out from the Tower of Hanoi a, so next, if we place this disk a1 on the Tower of Hanoi, programming in the example of the number of disks to be moved is 1. is completed. That is, the user issues a command ' al b that instructs to place the disk a1 on the tower of Hanoi.
``push'' is input from the keyboard 103.

This command is also first added to the program storage area 933 as an entry 913 and displayed as text 1201 in the scene 1001 (step 204).
Command 1201 is a built-in command (step 20
5) 'pus' of the built-in command execution library 109
h' is executed in the command execution subroutine 515 (step 206).

As shown in FIG. 5, the 'push' command execution subroutine 515 adds the disk a1 specified by the first argument as the top disk of the Tower of Hanoi specified by the second argument (step 516). , reports successful command execution (step 517), and ends (step 518).
).

Next, the scene control program 106 executes the command 12o1
In order to animate the command 1201, the ``push'' command animate subroutine 613 in the built-in command animation library 110 is called (step 207).As shown in FIG. Disk a1 with one argument
The 'push' operation is animated by moving and displaying it little by little to the position of the Tower of Hanoi, which is the second argument (step 614), and the Tower of Hanoi, which is the second argument, is displayed in scene 1001. (Step 6)
15), and ends (step 616).

In this redisplay, a disk is added to the Tower of Hanoi, so when the animation of the command 1201 is finished, the Tower of Hanoi will be in the state shown in the display 1105 of FIG. 12. This completes the movement of the disk and completes the programming in the example where the number of disks moved is 1.The user can input the command '5uccess-end' on the keyboard 1 to indicate the end.
Enter from 03.

The '5uccess-end' command, like other commands, also uses the program storage area 9 for scene 1001.
33 entries 914, and the first
Scene 10 as text 1202 as shown in Figure 1
01 is displayed. Execution of the command 1202 is immediately successful and the end of scene creation is reported (steps 524-526) as shown in FIG. 5, and the '5uccess-end' command animation subroutine is executed as shown in FIG. 621 ends immediately without doing anything (
step 622).

When the completion report by command 1202 is detected (step 209), the scene control program 106 ends.

This completes the creation of program 9335, which solves the Tower of Hanoi problem on scene 1001 when the number of moving disks is 1. As described above, in the program creation method of the present invention, there are problems to be solved.

It is visualized as a concrete shape image that is close to the original shape, and each step of problem solving is made into an animation, so
The feature is that programs can be created while maintaining a sense of realism.

Now, as already mentioned, how to create a program using the method of the present invention to solve the Tower of Hanoi problem in general, that is, to move a group of disks from one tower to another with an arbitrary number of moving disks. , it is sufficient to create a scene using an example in which the number of moving disks is two. Therefore, the process of creating the scene 1301 and the operation of the scene control program 106 in an example in which the number of movable disks is two will be explained next.

When the user starts executing the scene control program 106, the example setting subroutine 107 is first called (step 202), as in the case of the scene 1001 in which the number of moving disks is one. Number N that indicates a number
The example value is 2, and one of the Tower of Hanoi data has two disks, and the other two are empty.The user sets the example from the keyboard 103.0 When the example setting is completed The state of the scene 1301 is shown in FIG. 13. As shown in FIG.
, 1305, 1306. and text 1303 indicating the name and type of the argument are displayed. Further, a program storage area 934 corresponding to the scene 1301 is created in the user program library 113 (step 302),
Information 917 to 924 indicating the name and type of example data is stored (steps 303 to 307).

When the example setting is completed, the scene control program 106 enters a loop (steps 203 to 209) in which commands from the user are sequentially read and executed. First, the user uses a command to confirm that the number of moving disks is greater than 1.
Nl>' is input from the keyboard 103. As a result, the scene control program 106 is stored in the program storage area 93.
4 stores the entry 925 and the text 140
1 in the scene 1301 (step 204), since the command 1401 is a built-in command (step 20
5) is executed by the built-in command execution library 109 and success is reported (steps 512 to 514). The built-in command animation library 110 then highlights 1 (steps 610 to 612) and ends the execution.

Next, suppose that the user wants to solve the example of the Tower of Hanoi with two moving disks by induction. In other words, the number of moving disks is 1
Since the 1st example has already been solved, you can use this to create a scene for the 2nd example. To do this, the user first inputs the command 'Nl-' from the keyboard 103 to reduce the data N indicating the number of moving disks by 1. This is to use the example of N-1, that is, the scene 1001. Command 'Nl
- is read by the scene control program 106 (step 203), the entry 926 is entered in the program storage area 934.
is added and text 1402 is added to scene 130.
Since the 1-' command is also a built-in command, the built-in command execution library 109 is called and executed (step 206).
As a result, the value of data N becomes 1 and success is reported (
Steps 505-508). Next, the built-in command animation library 110 is called (step 207), and 2
The value of data N, which has changed from 1 to 1, blinks and is highlighted (steps 604-604), and command 14
Processing of 02 is completed.

Now, as can be seen from Figure 13, in order to move the two disks on Tower of Hanoi 1304 to Tower of Hanoi 1305, first move the upper disk of Tower of Hanoi 1304 to Tower of Hanoi 1306. After that, move the disk that was under the Tower of Hanoi 1304 to the Tower of Hanoi 1305, and finally move the disk that was moved above the Tower of Hanoi 1306 to the Tower of Hanoi 13o5.

Therefore, the user first inputs the command 'Nacb hanoi' via the keyboard 103. This command means to move the disk by the number indicated by the current value of N, 1, from Tower A of Hanoi to C.

As mentioned above, in the example where the value of N is 1, this command can be executed because the user program 933 corresponding to the scene 1001 that solves the problem has already been created on the user program library 113. Specifically, the scene control program 106 executes the command 'Nabc hano
i' is read (step 203), an entry 927 is added to the user program storage area 934, and text 1403 indicating the command is added to the scene 1301.
(step 204), now 'hanoi
'Since the command is a user program and not a built-in command (step 205), the scene control program 106 calls the user program library execution subroutine 112.

The eighth time is a flowchart showing the operation of the user program library execution subroutine 112. As shown in FIG. 8, when the user program library execution subroutine 112 is called, first the command name 'hanoi' is selected from the user program library 113.
The first program storage area 933 having a program name equal to is found, and the example data names N, a, b, c in area 933 correspond to the argument groups N, a, c of the command 1403.
c and b are replaced (step 801). That is, the name used in the entry in area 933 is C.
, and C is replaced by b. As a result, entry 913 is replaced with a command 'a 1 c push'.

The user program library execution subroutine then retrieves the command 'N 1 =' in entry 911, which is the first command stored in area 933 (step 802), since this is a built-in command (step 8).
03), the built-in command execution library 109 is called and executed (step 804). This command succeeds because the current value of N is 509 to 51.
1). The built-in command animation library 110 is called and highlighted (steps 607 to 609).
, the command execution was successful (step 807), so it is checked whether the next command storage entry exists in the user program storage area 933 (step 808), and since entries 912 to 914 still remain, the next line, i.e. This is the command stored in entry 912.'
a pop' (step 809) and execute it.
Since the tPo and p commands are also built-in commands (step 803), the built-in command execution library 109 is called and executed (step 804), and as a result, the upper one of the two disks of Tower a of Hanoi is 81 is named and deleted from a (steps 519 to 523).
. Next, the built-in command animation library 110 is called, and scene 1 shows how the disk a1 rises in the Y direction.
A moving image is displayed at 301 (steps 617 to 620).

Next, user program library execution subroutine 11
The command stored in entry 913 is executed by 2, but as mentioned above, the example data name 'b' in entry 913 has been replaced with 'c', so the command 'a 1 c push' is executed by the built-in command execution library 109 (step 804).
, the execution state is animated in the built-in command animation subroutine 110 (step 805). That is, the state in which the disk a1 is placed on the Tower C of Hanoi is animated on the scene 1301 and displayed on the display device 101 (
Steps 613-616).

The command in the next entry 914 is '5uccas-
end ' command, its execution immediately succeeds (steps 524-526) and ends. At this point, the entries in the program storage area 933 are exhausted (step 808), so the example data name is restored to its original state (step 808).
11) The calling of the user program library execution subroutine 112 is completed. FIG. 14 shows the display state of the scene 1301 at this stage.

Since the upper disk in the Tower of Hanoi 1304 has been moved to the Tower of Hanoi 1306, the user next moves the disk remaining in the Tower of Hanoi 13o4 to the Tower of Hanoi 13o5. This includes the command 'a' as shown in Figure 15.
pop' from the keyboard 103, and then
6. Run the command ' al b push ' as shown in figure 6.
Enter. The processing of these two commands is the same as command 11o2 in FIG. 11 and command 1201 in FIG. 12, and as shown in FIG.
Entries 928 and 929 are added to 34, and
Texts 1501 and 1601 indicating commands are displayed on the scene 1301 (step 204), and the movement of the disk from the Tower of Hanoi 1304 to the Tower of Hanoi 1305 is animated on the scene 1301 (step 206).
, 207).

In order to obtain a solution for the Tower of Hanoi problem where the number of moving disks is two from the state of scene 1301 shown in FIG. 16, it is sufficient to move the disk on the Tower of Hanoi 1306 to the Tower of Hanoi 1305. , for this we use the idea of induction as before.

That is, for the example in which the number of moving disks is 1 (N-1), the fact that the program 933 has already been obtained through the creation of the scene 1001 that solves the problem is utilized. To do so, the user must use the command 'g' N c b a ha
noi' is input from the keyboard 103 (step 203).

The scene control program 106 executes command 1 in FIG.
Process this command in the same way as for 403. That is, first, the entry 930 is added to the program storage area 934, and the text 1701 is displayed in the scene 1301 (step 204). Since the command 1701 is a user-defined command and not a built-in command (step 205), the user program library execution subroutine 112 is called (step 208).
). As shown in FIG. 8, the user program library execution subroutine 112 executes the command name 'hanoi
' For the program 933 that has the example data names N, a, b, c are replaced with the argument names of the command 1701, N, c, b, a (step 801
), the entry 912 of the program 933 is l
To Cp op +.

Also, entry 913 is replaced with 'cl b push'. All of the entries stored in entries 911 to 914 are built-in commands and are executed by the built-in command execution library 109 (step 804).
, the execution state is animated on the scene 1301 by the built-in command animation library 110 (step 80
5). Since the current value of N is , command 911 ('N
1=') is successfully executed in steps 509-511)
, the display 1302 blinks and is highlighted (step 607
~609).

As a result of executing the command 912 ('c ρ0ρ'), the disk c1 is deleted from the Tower of Hanoi C (steps 519 to 523), and the rising of the disk c1 is animated (steps 617 to 620). ).

Next command 913 (' cl b push '
), the disk c1 is added to the tower of Hanoi (steps 515 to 518), and the movement of the disk c1 to the tower of Hanoi is animated (steps 613 to 518). 616), the next command 914 (' 5u
Since the execution of ccess-end ') is immediately successful and the completion is reported (steps 524-526), the user program is terminated (step 808), and the example data name is restored and entry 912 is changed to 'apop'. , the entry 913 becomes 'al b pop' (step 811), and the calling of the user program library execution subroutine 112 is completed (step 8).
12).

Thus, in the state shown in Figure 13, the two disks that were on top of the Tower of Hanoi 1304 are now on the Tower of Hanoi 1304 as shown in Figure 17.
Move to 5.

The user also uses the commands 'N 1 +' and ' 5u
After inputting ``ccess-end'' from the keyboard 103 and returning the value of N that was decreased by 1 using a command 1402, the creation of the scene 1301 is completed. FIG. 17 shows a scene 1301 in this state, that is, a state in which the value of numerical data 1302 indicating the number of moving disks has finished solving the Tower of Hanoi problem in two examples.

As described above, according to the program creation method of the present invention, a program can be created with the feeling of operating a real object.

Program 9 in the user program library 113 obtained through the creation of scene 1001 and scene 1301
Programs 33 and 934 are created for an example in which the number of moving disks is 1 and an example in which the number of moving disks is 2, respectively, but they are operable for any number of moving disks. I will briefly explain this below. For example, data N indicating the number of moving disks is 3, Tower of Hanoi data a has 3 disks, and Tower of Hanoi is C. Assume that there is no disk. At this time, the user enters the command 'N' from the keyboard 103.
When a b c hanoi' is input (step 203), since the 'hanoi' command is not a built-in command (step 205), the user program library execution subroutine 112 is called (step 208). As shown in FIG. 93
3 is searched, and since the data name and argument name match in one example, each entry does not change and the commands therein are executed sequentially. However, command 911 ('N1=')
fails because the value of N is 3 (steps 509 to 5
11), the user program library execution subroutine 112 receives a report of command execution failure (step 80).
7) Extracts another program, Progera 934, having the same command name 'hanoi' from the user program library 113 (step 81o).

The commands in the program 934 are then executed sequentially. The command 925 ('Nl>') succeeds this time because the example value of N is 3, and the next command 926 'Nl-'
Therefore, the value of N becomes 2. Next command 927 ('
Nacbhanoi') is from tower a of Hanoi to c,
The command is to move N disks (two disks), but an example where N is two can be processed by creating a scene 1301. Specifically, since the 'hanoi' command is not a built-in command (step 803)
, user program library execution subroutine 112
is called recursively (step 806). As is well known, a recursive call is a type of procedure call that calls the same subroutine again within a certain subroutine. Many programming languages 1 e.g. PASCAL,
Recursive calling is possible in C, LISP, etc., and if the scene control program 106 and subroutines 107 to 112 are created using these languages, step 806
Recursive calls are easily implemented. User program library execution subroutine 112 executes command 927
When called recursively by ('Nacbhanoi'), program 933 is first retrieved, and each command is executed after replacing the example data name.
11 (N1=') fails, the program 934 is retrieved again, and the example data name 'Nabc is the argument name 'Nacb'.
It is executed after being replaced with . After N is decreased by 1 and becomes 1 in command 926, program 934 contains a non-built-in command 927 (because II replacement has occurred).
N a c bhanoi ') appears, and further recursive calls occur (step 806).
, the program 933 is retrieved and executed again, but this time the command 911 ('N1=') is successful,
The remaining commands 912 to 914 are all built-in commands, and the second recursive call of the user program library execution subroutine 112 is completed successfully.
By executing the frame ('N1+') when = 1, N becomes 2 and the first recursive call is completed, and command 927
The execution of ('N a b chanoi'') also completes successfully.Now, as a result of the execution of this command 927, the two disks move from a to C.The next command 928 ('apo
p') and command 929 ('albpush'
), the disk remaining in Tower a of Hanoi moves to b. And the next command 930 ('N a b cha
noi ') is to move two disks from Tower C of Hanoi to b, and the example where N is 2 is scene 130.
Since it has been solved as 1, it is executable (command 92
7, the user program library execution subroutine 112 is recursively called), the two disks that had been moved to C by command 927 are moved to b, and
A total of three disks are placed on the zero-order command 931 (
'N1+') and command 932 ('5ucca
ss-end') ends the execution when the number of moving disks is 3. It is clear from the above explanation regarding the case where N is equal to 3 that it can also be implemented when N is even larger than 3.

〔Effect of the invention〕

According to the present invention, it is possible to obtain a program by visualizing the objects on which the program is intended to be operated as they are and operating them, thereby making it easier to create the program. In addition, since each data operation is made into a video, it becomes possible for even non-computer experts to easily familiarize themselves with the programming, which gives a sense of realism.The scope of programming is expanded, and more diverse programs can be created. This also has the effect of alleviating the problem of a shortage of programmers.

[Brief explanation of drawings]

Fig. 1 is a block diagram of a system that implements the program creation method of the present invention, Fig. 2 is a flowchart showing the operation of the scene control program, Fig. 3 is a flowchart showing the operation of the example setting subroutine, and Fig. 4 is the data display. FIG. 5 is a flowchart group showing the operation of a subroutine group in the built-in command execution library; FIG. 6 is a flowchart showing the operation of a subroutine group in the built-in command animation library. 7 is a flowchart showing the operation of the user program library generation subroutine, FIG. 8 is a flowchart showing the operation of the user program library execution subroutine, FIG. 9 is a diagram showing the contents of the user program library, and FIGS. 10 to 12. Figures 13 to 17 show different screens in the process of creating a program to solve the Tower of Hanoi problem when the number of moving disks is 1, and Figures 13 to 17 are for solving the Tower of Hanoi problem when the number of moving disks is 2. FIG. 18 is a diagram showing different screens in the program creation process, and is a diagram showing an example of a program for solving the Tower of Hanoi problem according to the prior art. 106... Scene control program, 107... Example setting subroutine, 108... Data display library,
109...Built-in command execution library, 110.
- Built-in command animation library, 111... User program library generation subroutine. 112...User program library execution subroutine. 13...User program library $3121 Figure 7 Half 23 Figure 12 (a (ton (C) (5ANox [yu] C] [) 23) 3 → t ENI)

Claims (1)

[Claims] 1. In a computer having a processing device, an input device, and a display device for displaying character strings and figures, the step of setting a specific example value to data, and the step of setting the data with the example value set. , a step of displaying a figure on a display device as a figure corresponding to the type of data prepared in advance, a step of storing a command string input by the programmer as a program, and a step of displaying a figure corresponding to each command for a group of data manipulation commands prepared in advance. The method includes a step of executing a process, a step of displaying the process of each command as a corresponding video for a group of data manipulation commands prepared in advance, and a step of sequentially executing a command string stored as the program. A program creation method characterized by the following. 2. In the program creation method according to claim 1, executing a process for a command prepared in advance includes a step of reporting whether the execution of the command is successful or unsuccessful;
A method for creating a program, further comprising the step of displaying the processing corresponding to each command as a different animation depending on whether the command execution is successful or unsuccessful. 3. Setting an example value for the data, displaying the data as an example image, storing the command string issued for the displayed example image, and responding to the command according to the example value of the data. 1. A method for creating a video, comprising the steps of: displaying a different video using a different method; and sequentially executing a stored command sequence to create a video.