Abstract:
A system and method for quickly discerning a process&#39;s completeness via graphical representation of processes by graphical objects with associated embedded symbols is disclosed. The present system and method decreases design time and increases personnel deployment efficiency.

Description:
RELATED APPLICATIONS 
       [0001]    This application claims priority to U.S. Patent Application Ser. No. 61/812,154, titled “System and Method for Embedding Symbols Within Software Development Space” filed Apr. 15, 2013, and incorporated herein by reference. This application is also related to and references co-owned U.S. patent application Ser. No. 13/490,345, titled “Method For Automatic Extraction of Designs From Standard Source Code,” filed Jun. 6, 2012, and which is fully incorporated herein by reference. 
     
    
     BACKGROUND 
       [0002]    Graphical representations of designs are dynamic for the placement of design objects but are typically static when it comes to describing the completeness of any particular design object. 
       SUMMARY OF THE INVENTION 
       [0003]    Being able to quickly discern an object&#39;s completeness allows the developers to focus their attention where needed. This decreases design time and increases personnel deployment efficiency. 
     
    
     
       BRIEF DESCRIPTION OF THE FIGURES 
         [0004]      FIG. 1  depicts one exemplary system for generating and monitoring embedded symbols, in one embodiment 
           [0005]      FIG. 2  shows one exemplary hierarchical decomposition graph that represents a software design processable by the system of  FIG. 1 . 
           [0006]      FIG. 3  shows a hierarchical design graph showing a graphical object options list, in one embodiment. 
           [0007]      FIG. 4  depicts the hierarchical design graph of  FIG. 3  after the description option is selected. 
           [0008]      FIG. 5  depicts an exemplary hierarchical design graph including embedded symbols, in one embodiment. 
           [0009]      FIG. 6  depicts the hierarchical design graph of  FIG. 5  wherein the “K” embedded symbol has been selected. 
           [0010]      FIG. 7  depicts the hierarchical design graph of  FIG. 5  after the keyword submit button of  FIG. 6  has been selected. 
           [0011]      FIG. 8  depicts an exemplary hierarchical design graph including completion information, in one embodiment. 
           [0012]      FIG. 9  depicts an exemplary method for determining completion information of a software design, in one embodiment. 
           [0013]      FIG. 10  depicts an exemplary hierarchical design graph including a find incomplete objects buttons, in one embodiment. 
       
    
    
     DETAILED DESCRIPTION 
     Definitions 
       [0014]    The following definitions provide guidelines for interpretation of the terms below as used herein: 
         [0015]    Function—a software routine, or more simply an algorithm that performs one or more data transformations. 
         [0016]    Control Kernel—A control kernel, also known as a “control” and/or a “control transform,” is a software routine or function that contains the following types of computer-language constructs: subroutine calls, looping statements (for, while, do, etc.), decision statements (if-then-else, etc.), and branching statements (goto, jump, continue, exit, etc.). 
         [0017]    Process Kernel—A process kernel, also known as a “process” and a “process transform,” is a software routine or function that does not contain the following types of computer-language constructs: subroutine calls, looping statements, decision statements, or branching statements. Information is passed to and from a process kernel via memory (e.g., RAM). 
         [0018]    State Machine—A state machine, as used herein, is a two-dimensional network that links together all associated control kernels into a single non-language construct that activates process kernels in the correct order. The process kernels form the “states” of the state-machine and the activation of those states form the state transitions. This eliminates the need for software linker-loaders. 
         [0019]    State Machine Interpreter—a State Machine Interpreter is a method whereby the states and state transitions of a state machine are used as active software, rather than as documentation. 
         [0020]    Finite state machine—A finite state machine is an executable program constructed from the linear code blocks resulting from transformations, where the transformation-selection conditions are state transitions constructed from the control flow. 
         [0021]    Terminator—A terminator is an event that occurs outside the scope of the current system or function. 
       Computing Environment 
       [0022]      FIG. 1  depicts one exemplary system  100  for embedding symbols  124  within a visual representation  120  of a software design  110  to indicate completeness. System  100  includes a development server  101  that is located, for example, within cloud  160 . Cloud  160  utilizes a computer communication network that may include the Internet and other computer networking technologies. 
         [0023]    Development server  101  includes a processor  106  and a memory  102 . Memory  102  stores software design  110  and a visual representation generator  108  that has machine readable instructions that are executed by processor  106  to generate a visual representation  120  of software design  110 , illustratively shown stored within memory  102 . Software design  110  is based upon a massively parallel hierarchical design model that defines work from the most abstract level down to a level of code. Visual representation  120  is a visual representation of at least part of software design  110 , and may represent a decomposition graph for example. The decomposition graph may include a global view showing all decomposition levels, processes and sub-graphs.  FIG. 2  shows one exemplary hierarchical decomposition graph  200  that may represent visual representation  120 . 
         [0024]    Visual representation generator  108  generates embedded symbols  124  for each process  122  within visual representation  120 . 
         [0025]    Memory  102  also includes a completion calculator  130  that has machine readable instructions executable by processor  106  to generate completion information  132 . Completion information  132  may be displayed on visual representation  120  by visual representation generator  108 . Optionally, completion calculator  130  identifies one or more uncompleted processes  122  and may be user initiated or an automated process of system  100 . 
         [0026]      FIG. 2  shows one exemplary hierarchical decomposition graph  200  that represents software design  110  of  FIG. 1 . Within hierarchical decomposition graph  200 , dashed lines represent control flows C 1 -C 11 , solid lines represent data flows D 1 -D 8 , dashed circles represent control transforms CNT 1 -CNT 3 , solid circles represent process transforms, rectangles represent data stores 1-3 and squares represent terminators T 1 -T 2 . Each decomposition level contains one or more sub-graphs  202 , one sub-graph for each decomposing process. Each sub-graph  202  may be considered a code snippet in the McCabe sense. A process may decompose into a sub-graph with a minimum of two processes. A process that decomposes into a single lower-level process is not a valid decomposition as no additional graph information is added. 
         [0027]      FIG. 3  shows a hierarchical design graph  300  with a graphical object options list  302 . Within hierarchical design graph  300 , graphical objects  304 ,  305 ,  306 ,  308 ,  309 ,  310 ,  312 , are objects that represent either processes, in the case of objects  304 ,  305 ,  308 ,  309 ,  310  and  312 , or a data store, in the case of data store  306 . Specifically, objects  308 ,  309  represent processes that decompose into lower levels, objects  304 ,  305  represent processes that do not decompose into lower levels, object  310  represents a control process, and object  312  represents control from a higher decomposition level. Data store  306  is represented by a rectangle. Objects  304 - 312  are connected by connections  330 - 346 . In an embodiment, objects  304 ,  305 ,  308 ,  309 ,  310 , and  312  represent processes  122 ,  FIG. 1 . 
         [0028]    In the embodiment of  FIG. 3 , objects  304 ,  305  and data store  306  are graphical objects that require information to transform from representations to design elements. Such information is added by selecting the graphical object, which causes graphical option list  302  to be displayed on hierarchical design graph  300 . In the example of  FIG. 3 , graphical option list  302  is displayed for object Tin Free Tin  305  and includes a description item  314 , a keywords item  316 , a test procedures item  318 , and a requirements traceability item  320 . For object  305  to be considered complete, certain listed items should exist. For example, selections  314 - 320  are user selectable and require complete information for the associated process to perform its required function. Other items may exist within option list  302 , for example, a Pass Data item, a Tag item, a Loops item, a Rename item, etc., but may not be required for object  305  to be considered complete. 
         [0029]      FIG. 4  depicts an exemplary pop-up window  402  displayed on the hierarchical design graph  300  of  FIG. 3 , such as when description item  314  is selected. A description  404  of an object may be entered within pop-up window  402  only after certain actions, for example, performing a two button selections process, such as right clicking an object to display option list  302 , and then selecting description item  314 . Thus, without the user performing these actions within graph  300 , it is impossible for the user to learn whether description  404  has been entered. To provide visual indications of entered data (i.e., completeness of the design), embedded symbols  124  (see  FIGS. 1 and 5 ) are displayed with hierarchical design graph  300  to provide a symbolic representation of the completeness of each object within software design  110 . Embedded symbols  124  may indicate that the associated object requires additional information or that the associated object has sufficient information to be considered complete. A user (e.g., a developer, administrator, etc.) may select one of the embedded symbol  124  to open a pop-up window (e.g., pop-up window  402 ) and enter information. This single click access saves time and effort of developers. 
       Embedded Symbols 
       [0030]      FIG. 5  depicts hierarchical design graph  300  of  FIG. 3  with embedded symbols  124  of  FIG. 1 . Objects  304 - 310  are either static (meaning they are not changeable by the user) or drag-and-drop (meaning they are created from a template defined elsewhere within software design  110  and positioned within hierarchical design graph  300 —i.e., movable). Embedded symbols  124  indicate whether certain attributes of the associated object/element have been entered and which attributes still need to be defined. Embedded symbols  124  are not directly modifiable, but facilitate modification of certain attributes of the associated object/element. 
         [0031]    There are four exemplary embedded symbols shown in  FIG. 5 . Not all the embedded symbols are labeled for clarity of illustration. Embedded symbol  124 ( 1 ) “K” indicates that process associated with object  305  lacks a keyword list. Embedded symbol  124 ( 2 ) “D” indicates that process associated with object  305  lacks a description. Embedded symbol  124 ( 3 ) “R” indicates that process associated with object  305  lacks at least one requirement. Embedded symbol  124 ( 4 ) “T” indicates that process associated with object  305  lacks a test procedure. More or fewer embedded symbols may be utilized without departing from the scope hereof. 
         [0032]    As discussed above, embedded symbols  124 ( 1 )-( 4 ) not only communicate to a user that additional information is required, but provide a single click process, that is, selecting with a single click one of embedded symbols. This single action causes to be displayed an input screen for entering the required data, for more details see  FIG. 6 . 
         [0033]    In one embodiment, if an embedded symbol  124  is visible then the functionality represented by that symbol has not yet been accomplished for the associated element. For example, if a description (e.g., description  404 ) has been entered for object  305 , then embedded symbol  124 ( 2 ) is not displayed. 
         [0034]      FIG. 6  depicts hierarchical design graph  300  of  FIG. 3  and a keyword pop-up window  602  resulting from selection of embedded symbol  124 ( 1 ) “K” of  FIG. 5 . That is, selection of embedded symbol  124 ( 1 ) “K” causes system  100  to display keyword pop-up window  602 . Similarly, system  100  displays other pop-ups when other embedded symbols  124  are selected by the user. A user/developer may then enter keywords  604  related to object  305  associated with embedded symbol  124 ( 1 ) “K”. Pressing a submit button  606  stores the user entered keywords  604  in association with object  305 . 
         [0035]      FIG. 7  continues with the example of  FIG. 6  and depicts hierarchical design graph  300  after keyword submit button  606  of  FIG. 6  has been selected. Embedded symbol  124 ( 1 ) is no longer displayed since the keyword required for object  305  has been entered. Accordingly, when all required attributes have been entered, no embedded symbols  124  are displayed for object  305 . 
         [0036]    Where a user desires to re-access, for example, the keyword list (i.e. keyword pop-up window  602 ), a user may right click on object  305  and select a keywords button. In one example, referring to  FIG. 3 , a user may select keywords button  316  to re-access keywords popup window  602 . 
         [0037]    In certain embodiments, embedded symbols  124  are only visible to privileged users. For example, privileges include: no privilege, read-only privilege, and edit privilege. If the user has no privileges then the Hierarchical Design Graph  300  is not accessible and, therefore, embedded symbols  124  cannot be displayed. Similarly, there is no reason to display the work-completion percentage (discussed in  FIG. 8 , below) to a worker with read-only privilege whom is not involved with the work or its management. Users with edit privileges are, for example, a manager or a developer that require access to embedded symbols  124 . 
       Automatic Hierarchical Design Graph Completion from Embedded Symbols 
       [0038]      FIG. 8  depicts exemplary hierarchical design graph  300  with embedded symbols  124  and a percentage complete indicator  802 . Since embedded symbols  124  indicate the per-graphical-object work left to be completed, system  100  may use this information to automatically calculate a graph-level-work percentage complete value for all displayed graphical objects of software design  110 . For example, system  100  may determine the graph-level-work percentage complete value as follows: 
         [0000]    
       
         
           
             
               
                 
                   
                     Percentage 
                      
                     
                         
                     
                      
                     of 
                      
                     
                         
                     
                      
                     Graphical 
                      
                     
                         
                     
                      
                     Object 
                      
                     
                         
                     
                      
                     Work 
                      
                     
                         
                     
                      
                     Completed 
                   
                    
                   
                     
 
                   
                    
                   
                     
                       P 
                       = 
                       
                         1 
                         - 
                         
                           A 
                           M 
                         
                       
                     
                     , 
                   
                 
               
               
                 
                   Equation 
                    
                   
                       
                   
                    
                   1 
                 
               
             
           
         
       
     
         [0000]    where ‘A’ equals the number of embedded symbols currently displayed and ‘M’ equals the total number of embedded symbols, displayed and not displayed. 
         [0039]    In exemplary graph  300  of  FIG. 8 , graphical objects  304 ,  305 ,  308 , and  309  each have four associated embedded symbols. However, for graphical objects  304  and  308 , the embedded symbols are not displayed, indicating that the associated information has been entered. For each of graphical objects  305  and  309 , two embedded symbols are displayed. Accordingly, by applying Equation 1 above, A equals four (i.e. two embedded symbols for each graphical object  305 ,  309 ) and M equals 16 (i.e. four embedded symbols possible for each graphical object  304 ,  305 ,  308 , and  309 ). Therefore, percentage complete indicator  802  shows that elements shown in hierarchical design graph  300  are seventy-five percent complete. In the embodiment of  FIG. 8  storage  306  and objects  310 ,  312  do not have associated embedded symbols, and therefore do not participate in the completeness calculation. 
         [0040]      FIG. 9  depicts an exemplary method  900  for determining completion information of a software design. 
         [0041]    In step  902 , a visual representation is generated for a software design. For example, visual representation generator  108  generates visual representation  120  having a plurality of graphical objects representing processes  122 . Each graphical object may have at least one embedded symbol  124  associated therewith. 
         [0042]    In step  904 , method  900  determines embedded symbol information for each graphical object within the visual representation generated in step  902 . For example, completion calculator  130  determines one or more of the total number of possible embedded symbols  124  for visual representation  120 , and the total displayed embedded symbols  124  for each process  122  within visual representation  120 . 
         [0043]    In step  906 , method  900  calculates the completion information for the software design. For example, completion calculator  130  calculates the percentage of embedded symbols  124  that are visible based upon the total number of embedded symbols, as determined in step  904 . Completion calculator  130  then stores completion information  132  within memory of system  100 . 
         [0044]    In optional step  908 , the completion information is displayed on the visual representation. For example, visual representation generator  108  displays completion information  132  concurrently with visual representation  120 . Accordingly, a developer viewing display  152  may know the progress of software design  110 . 
       Finding the Next Work Item Using Embedded Symbols 
       [0045]    In certain embodiments, embedded symbols show what work needs to be completed on a graphical object. A developer (i.e. developer using computer  150  of  FIG. 1 ) may search through visual representation to find graphical objects requiring work. 
         [0046]      FIG. 10  depicts an exemplary hierarchical design graph  1000  similar to hierarchical design graph  300  of  FIG. 5  with an additional incomplete object display  1002 . Selecting one of the “Find Incomplete Objects” buttons  1004 - 1012  within incomplete object display  1002  causes system  100  to invoke a completion calculator  130  to find the next graphical object requiring work corresponding to the user selected button  1004 - 1012 . Selecting the “ANY” button  1004  causes system  100  to find any object containing displayed embedded symbols. Selecting a button that corresponds to a particular embedded symbol (e.g., buttons  1006 - 1012 ) causes the system to find an instance of a graphical object containing the corresponding, displayed embedded symbol. The graphical object that is found with the selected embedded symbol may be indicated, for example, by highlight  1004 . In one embodiment, visual representation generator  108  cooperates with completion calculator  130  to search the current graph, for example, in a clockwise fashion. If no highlighted graphical object is found, it will then search each level of the hierarchical graph until such an object is found. If a highlighted object is found on another level of the graph then display  152  is updated to display that level of the graph. If no highlighted object is found anywhere in the graph then an information statement is displayed, for example, indicating “No Work Available”. 
         [0047]    Embedded symbols  124  allow users to instantly learn what work is left to be done on an object-by-object basis. This directs the work and provides a simplified work-status review model. In addition, embedded symbols grant fast, single-selection access to the to-be-performed work. Work-completion percentages may be calculated directly from embedded symbols. Finally, the ability to view embedded symbols may be controlled via the privileges granted to the user. 
         [0048]    Changes may be made in the above methods and systems without departing from the scope hereof. It should thus be noted that the matter contained in the above description or shown in the accompanying drawings should be interpreted as illustrative and not in a limiting sense. The following claims are intended to cover all generic and specific features described herein, as well as all statements of the scope of the present method and system, which, as a matter of language, might be said to fall there between.