JP2010186378A - Difference display system and method between versions of software - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To achieve the upgrading of software without damaging the usability of a user. <P>SOLUTION: A difference display system includes: a syntax difference extraction part configured of a series of steps of: syntax analysis, difference extraction by line unit, the mapping of the difference of the line unit and syntax elements, and the propagation of a hierarchical difference to the upper layer following the hierarchy of the syntax elements with respect to the source code before the upgrading of software and the source code after the upgrading of software; a UI extraction part for generating a calling relation tree concerning changed functions, and for retrieving UI elements linked to the calling of the changed functions by tracing the calling relation tree; and an explanation UI component insertion procedure part for specifying a proper UI component for explanation by detecting the pattern of the type and change of an UI element, and for embedding the specified component in a source code. <P>COPYRIGHT: (C)2010,JPO&INPIT

Description

  The present invention particularly relates to a technique for displaying a difference between software versions.

  As a technique for extracting and displaying software differences, there is a technique that not only compares line units of source code but also uses a hierarchical structure based on the syntax of the source code (Non-Patent Document 1). . This uses a hierarchical structure to propagate a difference between elements in a lower hierarchy to an upper hierarchy. As a result, in a scene where the developer wants to understand the difference between the versions, it is possible to understand the difference in order from the element of the upper layer having a coarser granularity.

Hierarchical difference of software components using diff, Japan Software Science Society FOSE’02 pp.171-174 (2002/11)

  In recent years, a system form in which a user accesses and uses software deployed on a web server from a web browser has become widespread. In the case of this system form, the software is upgraded on the server side without notifying the user. At this time, the user is forced to use the contents while understanding the contents of the change due to the version upgrade. The technology described in Non-Patent Document 1 is useful for developers to understand the difference between software versions, and is not intended for general users as software users. A general user does not need to understand the software at the granularity of the source code when using the system, and the source code is generally not disclosed to the user.

  In general, differences between software versions are often displayed in a list in a document such as a manual change history or help. However, when changing versions, many users have already used software in the past, and tend to use them without reading a document about differences. At this time, when the user encounters a difference between versions, the user may have a bad impression about the usability of the software, and there may be an adverse effect such as stopping the subsequent use.

  The present invention realizes a version upgrade that does not impair the usability of the user when the software version is upgraded on the server as described above.

  A system for solving the above problems will be described below. For the source code before and after the software upgrade, syntactic analysis, line-by-line difference extraction, line-by-line difference and syntax element mapping, high-level differences according to the syntax element hierarchy It includes a syntax difference extraction unit consisting of a series of steps of propagation to the layer. Corresponding UI extraction procedure that generates a call relation tree for a function that has changed, and traces the call relation tree to search for a UI (User Interface). A part. Next, an UI component insertion procedure unit for explanation is provided, which detects the type of UI element and the change pattern, selects an appropriate explanation UI component, and embeds it in the source code.

  According to the present invention, it is possible to mechanically embed an explanatory UI component for explaining the contents of change around a UI element corresponding to a change between software versions. As a result, the developer can show the changed portion to the user only by inputting an explanatory note of the changed content, and therefore the development man-hour can be reduced. Further, since the user can understand the change contents in a timely manner when using the changed UI element, the software can be upgraded without impairing the user's usability.

It is a system configuration diagram. FIG. 3 is a process flow diagram of the first embodiment. It is a figure of the example of a user screen before insertion of UI parts for description. It is a figure of the example of a user screen after insertion of UI components for description. It is a figure of the example of a source file before version upgrade. It is a figure of the example of a source file after version upgrade. It is a figure of the example of a source file after version upgrade. It is a figure of the example of a source file after UI parts for explanation are inserted. FIG. 10 is a process flow diagram of Embodiment 3. FIG. 10 is a process flow diagram of Embodiment 3.

  A programming language Java (registered trademark) is taken as an example, and an embodiment in the case where there is a button in a Web browser as a UI element related to the changed function will be described. The following example using the programming language Java as an example can be implemented in other programming languages as well, and can be implemented even if the UI element associated with the changed function is another element. .

  FIG. 1 is a configuration diagram of a system according to the present embodiment. The present embodiment relates to the software development computer 103 that realizes the processing flow shown in FIG. 2, but shows a configuration diagram including the user computer 101 and the software execution computer 102. The software development computer 103 includes a CPU 110c, a main storage device 112c, a secondary storage device 113, and a bus 111c that interconnects them. The main storage device 112c holds a syntax difference extraction unit 121, a corresponding UI extraction unit 122, and an explanation UI component insertion unit 123. The secondary storage device 113 includes a source file 124 before version upgrade, a source file 125 after version upgrade, a source file 126 after insertion of explanatory UI parts obtained through the processing of each part, and an execution file 127a obtained by compiling this Hold. However, each unit and file may exist anywhere as long as they can be processed as the software development computer 103 without necessarily having the configuration shown in FIG.

  The software execution computer 102 includes a CPU 110b, a main memory 112b, and a bus 111b connecting them. The main storage device 112b includes an execution file 127b transferred and copied from the software development computer 103 via the LAN 105. The execution file 127b returns a response to the request received from the user computer 101 via the WWW 104. The user computer 101 includes a CPU 110a, a main memory 112a, and a bus 111a for connecting them. The main storage device 112 a has a browser 120 and transmits a request to the software execution computer 102 via the WWW 104.

  FIG. 3 is a screen example (not shown of the display device) of the user computer 101 assumed in the system of the present embodiment. It is assumed that the user uses the software developed on the server (software execution computer 102) using the browser screen 301 opened by the browser 120. 3 assumes an SNS (Social Network Service) having a diary 302, a message 303, an album 304, and a schedule 305 as basic functions. The basic function shown in FIG. Is arranged as. Further, it is assumed that the lower part of FIG. 3 has a friend list 306, a diary list 307, and site information 308. In general, the change history between versions is displayed in a list at a site such as the site information 308, but the user tries to start using it without seeing it.

  FIG. 4 shows a state of the user's browser screen 401 given as a response to the execution file 127b after the insertion of the explanatory UI component. Here, it is assumed that a function for sharing a user's own schedule with a friend is added as a difference between versions. By inserting the explanation UI component, when the user moves the mouse cursor 410 to the schedule button 405, a pop-up screen 409 explaining the added function can be displayed. The flow of processing for realizing this is shown below.

  FIG. 2 is a processing flow diagram of the software development computer 103. It is roughly divided into a syntax difference extraction unit 121, a corresponding UI extraction unit 122, and an explanation UI component insertion unit 123. Hereinafter, the flow of processing will be described using the example of each source file shown in FIG. 5, FIG. 6, FIG. 7, and FIG. 8 and the processing flow diagram of FIG.

  A source file example 501 shown in FIG. 5 is an example of the source file 124 before version upgrade. Here, for simplification, a GUI having one button “buttonA” 502 as a UI element is assumed. A source file example 601 shown in FIG. 6 is an example of the source file 125 after version upgrade, and is assumed to be a version upgrade from the source file example 501 shown in FIG. In step 201 in the syntax difference extraction unit 121, syntax analysis of the source code shown in FIGS. 5 and 6 is performed. Thereby, a hierarchical relationship such as a function and each process in the function is grasped. In step 202, the source codes of FIGS. 5 and 6 are compared in units of lines, and differences are extracted. Accordingly, it is found that in the example of FIGS. 5 and 6, the process 503 in FIG. 5 and the process 602 in FIG. 6 have different process rows. In step 203, line-by-line differences and syntax elements are mapped. In the example of FIG. 6, the mapping between the line 602 extracted as the difference and the syntax element as the processing in the function is performed. In step 204, the hierarchy difference is propagated to an upper layer in accordance with the hierarchy of syntax elements. In the example of FIG. 6, the difference is propagated to the function “functionA” 603 which is the upper syntax of 602 as the processing, so that the function “functionA” 603 is recognized to have changed between the versions of FIG. 5 and FIG. be able to.

  Next to the syntax difference extraction unit 121, the corresponding UI extraction unit 122 performs processing. The state of the corresponding UI extraction procedure is shown using the changed source file 701 in FIG. In step 205, a call relation tree of the function that has been changed is created. In this embodiment, a call relation tree for the function “functionA” 702 that has been changed is created. In step 206, the UI element that leads to the call of the changed function is searched by tracing the call relation tree created in step 205. In the example of FIG. 7, the call 704 of the function “functionA” is connected to the function “buttonA” 703, and this is detected. Since the example of FIG. 7 is simplified, a direct call 704 to “functionA” is detected. However, there are cases where the call relation tree is detected by tracing the call relation tree many times.

  Following the corresponding UI extraction unit 122, processing by the explanatory UI component insertion unit 123 is performed. The state of the explanatory UI component insertion procedure 123 is shown using an example 801 of the source file 126 after the explanatory UI component is inserted as shown in FIG. In step 207, the type of UI element extracted in step 206 and the change pattern are detected. In the example of FIG. 8, the type of “buttonA” that is the searched UI element is a button, and the change pattern is “change of operation content when the button is pressed”. In step 208, appropriate UI parts for explanation are embedded in accordance with the type and change pattern of the UI element obtained in step 207. In the example of FIG. 8, in order to display a pop-up UI component for explanation when the mouse cursor is moved to a button, a description UI component declaration 802, a description UI component generation 803, and an operation of the explanation UI component Insert 804 respectively. The example of the UI component for explanation shown this time is a pop-up display when the mouse cursor is moved, but the UI element type and change pattern detected in step 207, such as displaying it from the beginning or displaying an animation, etc. In response, appropriate UI components for explanation are inserted. Specifically, when the cursor shape and its meaning necessary for screen operation are changed, the user needs to know the cursor as the UI element type and its change pattern (shape and its meaning) before the operation. Therefore, the UI parts for explanation are displayed from the beginning. In addition, as a method for easily showing the situation before and after the change to the user, animation display is used as an explanatory UI component.

  Finally, after the above steps, the developer performs step 209 to fill in the contents of the explanation UI component. Thereafter, the execution file 127a can be obtained by compiling the source file, and this is generally deployed in the computer 102 for software execution.

  By carrying out as described above, the developer only has to fill in the explanation content on the explanation UI component, and the effect of being able to present the difference information between the versions to the user in a timely manner is obtained.

  FIG. 9 is a processing flow diagram of the software development computer 103 in this embodiment. In the present embodiment, in the system configuration diagram shown in FIG. 1, a change history DB 903 is further included in the secondary storage device 113, and a change content operation unit for operating the change history DB 903 is further included in the main storage device 112c. It is included.

  The change history DB 903 holds a change history table 904. The change history table 904 holds a software version 905 and a change content 906 including a UI component for explanation and an explanatory text as a pair. Then, before executing the syntax difference extraction unit 121, the description history DB 903 is referred to in step 901 to recognize the past version explanation UI parts and delete them from the source code. In addition, after the developer goes through step 209 to fill in the contents of the explanation UI widget, the change contents in the latest version are inserted into the change history table 904.

  As described above, the developer can show only the latest change contents to the user without taking the man-hour of deleting the past explanatory UI parts.

  FIG. 10 is a processing flow diagram by the software development computer 103 in this embodiment. In the present embodiment, in the system configuration diagram shown in FIG. 1, the change history DB 903 and the last access time DB 1004 are further included in the secondary storage device 113. In addition, a change content operation unit for operating the change history DB 903 is included in the main storage device 112b. In addition, the main storage device 112c includes an access time procedure unit for operating the last access time DB 1004 and the change history DB 903 at the time of user access to perform processing to include an optimal explanation UI component.

  The change history DB 903 also stores a version time table 1008 in addition to the change history table 904 shown in the second embodiment. The version time table 1008 is a table that holds a pair of a software version 1009 and a time 1010 when the version 1009 is expanded. As processing steps, step 901 shown in the description of the second embodiment is not included, but step 902 is included. Further, after Step 902, Step 1011 is written in which the time 1010 at which the version 1009 is expanded is written in the version time table 1008.

  The last access time DB 1004 holds a last access time table 1005 that holds a user ID 1006 and a last access time 1007 as a pair. At the time of user access, in step 1001, the last access time DB 1004 and the change history DB 903 are referred to, and all the explanatory UI parts generated by the accumulated version change from the last access time 1007 that the user last accessed last time are extracted. In step 1002, source code in which the explanatory UI parts extracted in step 1001 are embedded is generated. This is compiled to generate an executable file 127b. In step 1003, the last access time 1007 stored in the last access time table 1005 is updated.

  As described above, the user can use the software while understanding not only the contents changed in the latest version but also the changes in all versions after the user's last use time.

  According to the embodiment described above, an explanation UI component for explaining the contents of change can be mechanically embedded around a UI element corresponding to a change between software versions. As a result, the developer can show the changed portion to the user only by inputting an explanatory note of the changed content, and therefore the development man-hour can be reduced. In addition, when the user uses the changed UI element, the user can understand the change contents in a timely manner, so that the user's usability is not impaired.

101: Computer for user, 102: Computer for software execution, 103: Computer for software development, 104: WWW, 105: LAN, 110: CPU, 111: Bus, 112: Main storage device, 113: Secondary storage device, 120 : Browser, 121: Syntax difference extraction unit, 122: Applicable UI extraction unit, 123: Explanation UI part insertion part, 124: Source file before version upgrade, 125: Source file after version upgrade, 126: Explanation UI part Source file after insertion, 127: Executable file.

Claims (6)

The first source code before the software upgrade and the second source code after the upgrade are parsed to obtain a syntax element, and the difference between the first source code and the second source code A syntax difference extraction unit that maps the difference extracted in units of lines and the syntax element, and propagates the extracted difference to an upper layer according to a hierarchy of the syntax elements;
Generate a call relation tree for the function including the syntax element mapped to the extracted difference, trace the call relation tree, and search for a UI element that leads to the function call; and
The UI element type and the change pattern are detected, an explanation UI component corresponding to the detected type and change pattern is selected, and the selected explanation UI component is embedded in the second source code A system for displaying a difference between software versions, comprising a UI part insertion unit. The content of the selected explanatory UI widget is further stored, and a change content operation unit is further provided for deleting the stored contents of the explanatory UI widget when the software is upgraded to the next version. Difference display system between listed software versions. The update time of the software, the change content operation unit that stores the contents of the explanatory UI parts at the time of the upgrade, and the user's last access time are stored, and the user accesses 2. The software according to claim 1, further comprising: an access-time procedure unit that generates a source code in which an explanatory UI component stored after the last access time is inserted by checking with the version upgrade time Difference display system between different versions. A method for displaying a difference between versions of software by a software development computer, wherein the software development computer includes:
Parsing the first source code before the software upgrade and the second source code after the version upgrade to obtain syntax elements,
Extracting the difference between the first source code and the second source code in units of lines;
Mapping the difference extracted in line units and the syntax element,
Propagating the extracted difference to an upper layer according to the hierarchy of syntax elements,
Generating a call relation tree for the function containing the syntax element mapped to the extracted difference;
Tracing the call relation tree, searching for UI elements that lead to the function call,
Detecting the type of UI element and the pattern of change;
Select explanatory UI parts corresponding to the detected type and change pattern,
The difference display method between software versions, wherein the selected explanatory UI component is embedded in the second source code. 5. The contents of the selected explanation UI widget are saved, and the contents of the saved explanation UI widget are deleted at the next version upgrade of the software. Difference display method. The version upgrade time of the software and the contents of the explanatory UI parts at the time of the version upgrade are stored, the last access time of the user is stored, and the version upgrade when the user accesses 5. The method for displaying a difference between software versions according to claim 4, wherein the source code is generated by inserting the explanatory UI parts stored after the last access time.

Images