WO2000049498A1 - Method and system for visual programming - Google Patents

Method and system for visual programming Download PDF

Info

Publication number
WO2000049498A1
WO2000049498A1 PCT/DE2000/000477 DE0000477W WO0049498A1 WO 2000049498 A1 WO2000049498 A1 WO 2000049498A1 DE 0000477 W DE0000477 W DE 0000477W WO 0049498 A1 WO0049498 A1 WO 0049498A1
Authority
WO
WIPO (PCT)
Prior art keywords
tree
operations
visualized
operand
operands
Prior art date
Application number
PCT/DE2000/000477
Other languages
German (de)
French (fr)
Inventor
Johannes Reichardt
Original Assignee
Johannes Reichardt
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Application filed by Johannes Reichardt filed Critical Johannes Reichardt
Priority to EP00909044A priority Critical patent/EP1161724A1/en
Publication of WO2000049498A1 publication Critical patent/WO2000049498A1/en

Links

Classifications

    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F8/00—Arrangements for software engineering
    • G06F8/30—Creation or generation of source code
    • G06F8/34—Graphical or visual programming
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F11/00—Error detection; Error correction; Monitoring
    • G06F11/30—Monitoring
    • G06F11/32—Monitoring with visual or acoustical indication of the functioning of the machine
    • G06F11/323—Visualisation of programs or trace data

Definitions

  • the present invention relates to a method for the visual programming of both algorithms and of higher-level program units, which supports different phases of the program life cycle by visualizing dependencies and relationships within a program system, i.e. makes visible.
  • the method is intended to replace textual programming with its known disadvantages in this regard.
  • AT&T "Method and Apparatus for displaying hierarchical information of a large software system ", EP 00650118 (1994) and AT&T:” Apparatus for visualizing Program Slices ", EP ' 00714064 (1995).
  • a method of making a program transparent at runtime by monitoring the objects is described in IBM: “Visualizing object-oriented software", EP 00689132 (1995). These methods have in common that they support traditional textual programming but do not replace them by visual methods.
  • a tree structure is edited by means of a graphical user interface, which shows the service elements of a hierarchically structured telecommunication service and their execution sequence. The service can then be executed by automatically interpreting the tree structure previously created.
  • Such methods which include programming in a broader sense, are typically used for configuration tasks. In general, you do not have the option of freely defining operations and operands and then freely linking them together within a control flow. They are therefore not suitable for replacing textual programming languages.
  • the method according to the invention can be assigned to the features "VPL-II.A.6 imperative" and "VPL-V.A general-purpose". This combination of features does not have any of the methods listed there (as of February 16, 1998).
  • VPL-II.A.6 The category of "imperative languages" (VPL-II.A.6), which are based on the allocation and control flow principle and which would be able to practice, is of particular importance for practice
  • VPL-V.A In the group of "universal languages” (VPL-V.A) the data flow methods (VPL-II.A.3) dominate with their respective visualization of the underlying data flow graph, e.g. Braine. L, Clack, C: "Object-Flow", 1997 IEEE Symposium on Visual Languages, Capri, Italy, Sept. 1997.
  • the data flow languages do not provide any syntactic elements for the sequentialization of instructions and are removed therefore very much from the programming style common in practice.
  • the acceptance of the textual data flow languages for professional use is correspondingly low.
  • a visual process of this kind which has nevertheless gained a certain practical importance, is the commercially available development tool "PROGRAPH CPX" (see [Poswig]).
  • VPL-VA Universal languages
  • VPL-II.A.5 the “functional languages”
  • VPL-II.A.5 are very similar to the data flow languages, especially in terms of the absence of Control flow concerns. In practice, they were generally unable to establish themselves as textual processes (exception: LISP).
  • the visualization here deals with the input-output relation of a function. See, for example, Erwi ⁇ , M .: “DEAL - A Language for Depicting Algorithms", in IEEE Symposium on Visual Languages, St. Louis, USA, Oct. 1994.
  • VPL-II.A.7 The "logical languages” listed in the group of “universal languages” (VPL-V.A) are based on the implication and application of inference rules.
  • the visualization here deals with logical expressions and their transformation. See, for example, A ⁇ usti, J. et al .: “Towards Specifying with Inclusions", in Mathware and Soft Computing, 1997.
  • functional languages these are languages which, on the one hand, do not exist in practice as textual processes prevailed (exception prologue) and their visualizations are still largely in the experimental stage.
  • VPL-V.A "form and table-based”
  • VPL-II.A.4 "form and table-based”
  • the invention is therefore based on the object of improving the previous visual programming methods in such a way that (1) that the visual programming is not restricted to a specific area of application, (2) that the paradigms of text programming, such as imperative and object-oriented programming style, which have proven themselves in practice , (3) that the visualization is complete and encompasses both the control flow, the structure of the operations and operands and the traversal of complex operands, and (4) that the visualization is uniform by using a visual program in one single graph can be displayed using a uniform structure.
  • VPL-VA general-purpose and “VPL-II.A.6 imperative”
  • the method according to the invention has the following further features according to the classification scheme of the Journal of Visual Languages and Computing: “VPL-II.A.9 object oriented "," VPL-II.B.1 diagrammatic ",” VPL-II.A abstraction (data, procedural) ",” VPL-III.B control flow “,” VPL.III.C data types and structures ",” VPL-III.D documentation “and” VPL-III.F exception handling ".
  • the task of programming a computer visually is achieved according to the invention in that a) the operations, consisting of simple and interleaved function and operation calls with their arguments, are visualized by a first tree structure in accordance with their neighborhood and inclusion relationships, b ) that the operands, consisting of simple and nested objects and data structures, are visualized by a second tree structure in accordance with their neighborhood and inclusion relationships, and c) that the relationships between the operations on the one hand and the operands on the other hand, consisting of argument -, assignment, element and other relationships can be visualized by line connections between elements of the first tree structure and elements of the second tree structure.
  • the main aim of the method is to visualize (1) neighborhood and abstinence relationships on the one hand and (2) usage or communication relationships on the other.
  • the shapes, colors, angles and dimensions of the geometry used play a subordinate role. Different geometrical designs are conceivable.
  • a terrace representation for tree Structures selected that appear advantageous due to their compactness.
  • the relationships according to (2) are visualized, likewise by way of example, by a lattice structure, which is preferred for its clarity.
  • the process is independent of the target language into which the visual program elements can be automatically translated. In principle, translation is possible directly into the machine code of a specific processor.
  • the object-oriented programming language C ++ is chosen here as the target language, which appears advantageous due to the scale and portability.
  • the selection of program modules made here is arbitrary.
  • the method is also applicable to an expanded or restricted set of program elements.
  • building blocks are selected that on the one hand appear useful for everyday programming, and on the other hand show the power of the visual process.
  • Rectangles (type H), which can contain further type H rectangles in a horizontal sequential arrangement, and can themselves be contained again in other type H rectangles in a horizontal sequential arrangement.
  • the arrangement should be disjoint and maintain fixed horizontal distances.
  • the height and width of the rectangles should depend on the height and width of the rectangles they contain and should adhere to fixed edge distances.
  • the distances should be chosen so that on the one hand there is a certain compactness of the overall structure, on the other hand the bracket structure obtained is sufficiently visualized.
  • the arrangement obtained in this way is called “horizontal nesting".
  • H-boxes H-boxes of a minimal, defined size, which themselves do not contain any further H-boxes, we call “atomic H-boxes" (see FIG.
  • Rectangles (type V). Which, in a vertical, sequential arrangement, contain further rectangles of type V can hold, as well as can be contained again in a vertical sequential arrangement in other rectangles of type V.
  • the vertical spacing and the border should be carried out analogously to the horizontal nesting. The arrangement obtained in this way is called “vertical nesting”.
  • V-boxes V-boxes of a minimum, defined height, which themselves do not contain any further V-boxes, we call “atomic V-boxes”. V-boxes are shown horizontally stretched. Their width depends on the width of a horizontal nesting assigned to them (see FIG. 2).
  • Rectangles that contain exactly one horizontal nesting in a vertical sequential arrangement, and underneath exactly one (possibly empty) vertical nesting.
  • the width of the innermost V-boxes of the vertical nesting of a unit corresponds to the width of the horizontal nesting above this unit.
  • Each unit should itself be an H-box again, so that units in the horizontal nesting one superordinate unit can occur.
  • Such an arrangement of units “hierarchy” (see FIG. 3). Lines connecting H-boxes of the horizontal nesting of a unit with V-boxes of the vertical nesting of the same or a higher-level unit in a vertical orientation. These lines can be provided with arrowheads at the upper or lower end or at both ends.
  • Arrows hit a V-box from above and end at its top edge.
  • a V-box can be hit at any point on the top edge.
  • An H-box is hit from below and ends on the left or on right end of its lower edge.
  • An arrow at the left end we call “L-arrow”, an arrow at the right end we call “R-arrow”.
  • An atomic H-Box is only hit in the middle of its lower edge (see Figure 4). Small diameter circles covering selected crossings of arrows with atomic V-boxes. We call such circles “crossing marks" (see FIG. 5).
  • Figure 1 shows a horizontal nesting (1) with atomic H-boxes (2) and non-atomic
  • Figure 2 shows a vertical nesting (1) with atomic V-boxes (2) and non-atomic V-
  • Figure 3 shows a hierarchy of units (1).
  • Figure 4 shows arrow connections between H and V boxes. With (1) are L arrows and with (2) are R-
  • FIG. 5 shows an intersection mark (1) on the intersection of an arrow with an atomic one
  • FIG. 6 shows the labeling of H and V boxes with names (1).
  • Figure 7 shows the labeling of H and V boxes with symbols (1).
  • FIG. 8 shows a sample program.
  • the program modules include arithmetic-logical expressions, control structures, object classes and higher functional units. We use terms from the object-oriented programming language C ++ to describe the semantics of these program modules. 5.3.1 Objects
  • a "composite object” is represented by a V-Box, a "simple object” by an atomic V-Box.
  • V-Box a "simple object” by an atomic V-Box.
  • simple objects “scalars” and “iterators”
  • composite objects "structures” and “containers”.
  • the V-boxes assigned to these four types can be distinguished by color.
  • a further differentiation of the objects takes place by labeling their V-boxes with class and object names, possibly followed by further details such as dimension, initial assignment, etc.
  • Figure 9 shows an example.
  • An "access" to an object is represented by an arrow.
  • An arrow emanating from the object symbolizes a read access that does not change the state of the object.
  • An arrow ending on it represents a write access that can change the state of the object.
  • Read and write accesses are identified by a double arrow. Multiple accesses to an object can take place side by side, to which as many arrows can then be assigned.
  • the chronological order of accesses is consecutively from left to right for arrows that begin or end on the same horizontal nesting level Different depths of the horizontal nesting take place one after the other from the inside out.
  • the horizontal expansion of the V-boxes visualizes the time axis with this restriction.
  • Figure 10 shows an example.
  • the horizontal expansion of the V-Boxes should also visualize the scope of validity and the lifespan of an object.
  • the scope of an object extends across the entire width of the horizontal nesting of a unit.
  • global objects with a graduated scope can be defined, globally for all subunits of the horizontal nesting of a unit.
  • the left end of a V-Box marks the instantiation of an object, the right end its extinction, determined by the active time of the unit.
  • a further differentiation of the area of validity and the service life can be made by selecting a storage class accordingly.
  • Scalars are objects whose inner structure is not visible. The inner structure is only accessed via element functions or operators. Built-in scalars can be made available, e.g. Integer or character. From this, as well as with the help of structures, containers and iterators, new objects can be formed, which in turn can be defined as scalar.
  • Figure 11 shows an example.
  • Structures are objects whose inner structure is exposed. They contain a fixed number of objects of any type in a fixed arrangement.
  • a structure can contain scalars, iterators, containers and again structures in vertical nesting without restriction.
  • the elements of a structure can also be accessed without element functions or operators by directing arrows on the structure elements.
  • Figure 12 shows an example.
  • Containers are objects that usually contain an indefinite number of objects of homogeneous type, which are combined in a regular structure (e.g. field, chain, tree). Containers are defined regardless of the data type of their elements. The data type of their elements is determined by inserting exactly one object of a certain type into them. The object used thus represents all container elements. Access to an element of the container is indicated by an arrow that ends or starts on the representative element.
  • Access to container elements usually takes place within a traverse, which runs through the regular structure of the container according to a schema and determines the element positions.
  • the flow scheme and the position currently reached within a container are separated from the actual container and combined to form an iterator object.
  • the iterator is also independent of the data type of the container elements.
  • the type of traversed container is part of the iterator type.
  • the class name of an iterator designates the algorithm of a traverse on a container of a certain type (not element type J). By accessing the iterator using its element functions and operators, the position of a container element managed in it can be changed according to the traversing algorithm.
  • trusses can be active on one container, as well as different trusses on several containers at the same time.
  • the selection and assignment of a traverse to a container is done separately for each access by placing an intersection mark on the intersection of the access arrow and the iterator.
  • the cross mark has the function of a dereference or content operator.
  • An assignment is only possible for iterators that are above the container. The assignment is documented by labeling the container with the object name of the iterator at the level of the access arrow.
  • a container as a whole is accessed without an iterator.
  • the access arrow ends on the container.
  • elements such as stack and queue can also be accessed.
  • access is via element functions or operators, with the access arrow also ending on the container.
  • Figure 13 shows an example.
  • An iterator can itself be an element of a container and in turn requires an iterator for the traverse and access. In this way, a container element can be addressed indirectly.
  • the assignments of iterators to containers that themselves contain reassigned iterators are marked as crossing points on the access arrow as above. Because an iterator is always above the container assigned to it, the overall assignment is cycle-free. The assignment between iterators and containers is also bijective per access.
  • Figure 15 shows an example.
  • DYNAMIC objects agreed as STATIC have a local area of validity related to a functional unit, but an unlimited lifespan - within the process runtime. Among other things, they are suitable for the initialization of local quantities.
  • the lifespan of DYNAMIC objects can be designed as desired, which e.g. can be used for the construction of containers.
  • the scope of DYNAMIC objects is generally global. They are available for access without restriction if their position is known.
  • STATIC variables are accessed according to the rules for structures, while DYNAMIC variables - like container elements - are accessed via iterators.
  • 'Create' creates an object of the type of the representative object used in the DYNAMIC container and returns the position of the created object as a return value, which is usually assigned to an iterator.
  • the element can also be deleted using this iterator, the iterator appearing as an argument to 'delete'.
  • the iterator for DYNAMIC is "built in”. It contains no truss function. In addition to the position (in the heap), it also manages the type specification of the DYNAMIC element.
  • a “compound expression” is represented by an H-box, a “simple expression” by an atomic H-box.
  • the H-boxes assigned to these expression types can be distinguished by color Further differentiation of the functions and operations takes place by labeling their H-boxes with function names or operator symbols.
  • Arguments are further differentiated into input, output and input-output arguments. Arguments can be marked with an arrow and thus represent the object which the arrow ends as a parameter of the function or operation.
  • Input arguments can can also be specified without a reil by directly (if necessary in abbreviated form) with the value o which are labeled with the name of a constant.
  • An argument is identified by its position within the argument sequence of a function or operation. Figure 17 shows an example.
  • a compound expression can also be an input argument to a function or operation.
  • the result of a function or operation is represented by the H box of its call and can be used by inserting it directly at the position of a function or operation argument.
  • the data type of the result must match the data type of the function or operation argument.
  • Functions and operations can be used continuously in one another and generally form a horizontal nesting.
  • the result of a function or operation can also be used by "assignment". To do this, an R arrow is directed to the object to which the result is to be assigned.
  • the "element relationship" of a function or operation to an object is represented by an L-arrow between this function or operation and the object.
  • the direction of the arrow can be used to specify whether the object is changed or only read or both. In the case of neither The reading and writing relationship degenerates into an undirected connecting line.
  • the chronological order of the object accesses is consecutively from left to right for arrows that begin or end on the same horizontal nesting level. This also applies to the L and R arrows of the same H box. Access from different depths of the horizontal nesting takes place one after the other from the inside out.
  • Figure 18 shows an example.
  • a control structure is represented by a (highlighted) unit, which contains the following H boxes in its horizontal nesting from left to right: First a "prologue", which can contain any number of expressions (or even higher functional units), e.g. for one Initialization. The last (highlighted) unit of this prologue must be a printout. It represents the "pre-condition”. This is followed by one or more "cases". A case is each represented by a unit that is marked with a "post Condition "is labeled. This contains a comparison operator followed by a constant (value or name; DEFAULT is the name of a built-in post condition that corresponds to the ice or default case and is always fulfilled). A case is fulfilled if the calculation of the concatenation of pre-condition and post-condition gives the truth value 1. The truth values are evaluated in the order in which the cases are arranged. The first fulfilled case within the control structure is executed.
  • control structures can be "exceptions" and "threads", which can be used to express exception handling and parallelism.
  • Each sequence of operations to be carried out sequentially can be assigned a set of sequence of operations to be carried out sequentially, which carry out the exception handling.
  • sequences of operations to be carried out sequentially can be combined to form a block which is carried out simultaneously.
  • a hidden arrangement can be advantageous for these two structures, which becomes visible only when necessary (editing, animation, views, navigation).
  • Terminators 'throw', 'break' and 'continue' shown as a function (highlighted in color) can be used in the way known from C ++. They can be used to leave or modify a control structure.
  • the functional subunits contained in the horizontal nesting of a functional unit communicate via the objects of the vertical nesting of this unit (or each higher-level unit).
  • a function definition it is the local objects through which the expressions communicate.
  • Figure 27 shows an example.
  • a class definition it is the data elements via which the element functions communicate and which are global to the element functions.
  • a function library it is the global objects.
  • the highest system level it is the message, synchronization or distributed objects through which the processes communicate with each other. These objects are always accessed by the smallest functional units, which can access all objects of all higher-level units via vertical arrow access, since these are located inside each other in increasing width, from the inside out.
  • Figure 28 shows an example.
  • Terminators 'return', 'exit', 'abort', 'terminate' shown as a function (highlighted in color) can be used in the way they are known from C ++. They can be used to leave a functional unit.
  • the units of the function and the operation are labeled with the "function name" or the "operator symbol”. It corresponds to the call name or symbol.
  • the "call parameters” are identified with an arrow symbol as IN, OUT or IN-OUT parameters.
  • FIG. 8A shows an example. The order of their occurrence from top to bottom corresponds to the order of calling from left to right right.
  • the "return value" of the function or operation is passed as an argument of a color-coded terminator. There may be several such terminator calls, their Arguments are checked for consistency. The specification as an argument is also the type declaration of the return value.
  • a class is generally defined as a functional unit, which contains the units of the "element functions” in its horizontal nesting, and the "data elements” in its vertical nesting (global to the element functions). It is labeled with the "class name” that is used when an object of this class is instantiated.
  • the "configuration parameters" of the class follow in ⁇ > - brackets, e.g. an initial assignment, size, etc. that correspond to the constructor parameters.
  • Figure 29 shows an example.
  • the functional unit of the class is further differentiated into SCALAR, CONTAINER and ITERATOR, as well as STRUCTURE.
  • SCALAR SCALAR
  • CONTAINER CONTAINER
  • ITERATOR STRUCTURE
  • No other features are provided for Sealare.
  • the data elements of a sealar and an iterator are only accessible via element functions and are therefore of a private type.
  • a formal assignment must first be made between the container and the iterator, which allows an iterator to directly access the data elements of a container.
  • the assignment is made by entering the iterator class name in a list associated with the container.
  • the container class name is also assigned to the iterator.
  • the actual container is usually implemented using the DYNAMIC storage class.
  • the container elements are defined as STRUCTURE objects and contain iterator objects for their concatenation.
  • Structure classes are public types and allow direct access to their elements via access arrows. Similar to nested containers, they are created directly via editing functions and can be assigned to a higher functional unit to determine their scope.
  • Free functions that are not part of a class can be summarized in “function libraries” (interfaces). They too are defined as a functional unit and, in their vertical nesting, contain global objects via which the functions communicate.
  • a class that is used in the horizontal nesting of another class thus inherits all functions, operators and data elements of the enclosing class.
  • a subclass is defined at the same level as the functions and operators of the enclosing class. Within the sub-class, functions and operators of the upper classes can be redefined and identified as "virtual" or "static". The access of subclasses to the data elements of superclasses can optionally be restricted. By default, these data elements correspond to global (protected) sizes.
  • the scheme of the high ⁇ zonal nesting lets any simple inheritance relationship to Figure 32 shows an example
  • FIG. 30 shows an example of sectional diagrams obtained by omitting all details of a function or operation except for the objects identified as parameters and the name description.
  • the parameter objects can be shortened horizontally and displayed with their labels
  • FIG. 31 shows an example
  • FIG. 8A shows the known recursive algorithm Quicksort in a complete visualization according to the method described here.
  • the data part contains five objects, including four iterators, two of which are marked as input parameters.
  • the field of objects of the type 'int' to be sorted is an input and output parameter marked Write and read accesses to the iterators
  • the field 'a' as a whole is passed five times as a function argument.
  • Two read accesses to field elements are carried out via the iterators ⁇ and 'left'.
  • the comparison a [ij ⁇ a [l ⁇ nks] is carried out.
  • the operation part contains five function calls, two of which are recursive calls to Quicksort.
  • the function arguments partly consist of complex printouts.
  • FIG. 8B is intended to illustrate, by way of example and independently of a geometric design, the general topological principle of the method according to the invention, according to which an algorithm is visualized.
  • the tree structure (1) of the operations, the tree structure (2) of the operands, the auxiliary lines (3) for expanding the operands along the time axis, and the lines (4) for representing argument-assignment and element relationships can be seen their points of impact (5) and crossing marks (6)
  • FIG. 9 shows the four basic patterns of objects used here, SCALAR, ITERATOR, CONTAINER and STRUCTURE. Labeling with class and object names, sometimes with an initial value, results in completely specified object declarations.
  • FIG. 10 shows the access options for a nested object. the depth
  • FIG. 11 shows a write and read access to a SCALAR or ITERATOR
  • FIG. 12 shows write and read accesses to a STRUCTURE as a whole and to it
  • FIG. 13 shows read and write accesses to a container as a whole, as well as read and write accesses to container elements via an iterator of the 'inorder' class.
  • the iterator can be read and changed by the user
  • FIG. 14 shows read and write accesses to nested containers.
  • the tree of class 'tree' is accessed as a whole and therefore without an iterator.
  • Tree elements of class 'field' at depth 1 of the nesting are accessed via an iterator of class 'inorder'.
  • Field elements of class 'char' in Depth 2 of the nesting is done via an additional iterator of the class 'LtoR'.
  • the label next to the arrow indicates the assignment of iterators to containers
  • FIG. 15 shows indirect read and write access to a container of the class 'tree' and its elements of the class 'inf.
  • the iterator for the' tree 'container is itself an element of a container of the class eid' and therefore requires an iterator for access All involved, including embedded, iterators are marked by crossing points on the access arrow. The assignment is shown by the shading next to the access arrow.
  • Figure 16 shows the dynamic memory location allocation for an object of the class object 'with assignment of the object position to an iterator the dynamically generated object via an iterator. The object is deleted again by calling an element function of the DYNAMIC storage class
  • Figure 17 shows the call of a function with the name sort and with three arguments, and the call of the operator '+' with two arguments.
  • FIG. 20 shows a selective control structure as above, but before preconditioning with a prologue consisting of two operations.
  • FIG. 21 shows a selective control structure as above, but with an additional DEFAULT case that corresponds to an else statement
  • FIG. 22 shows a nesting of selective control structures which corresponds to an rf-then-if statement
  • FIG. 23 shows a selective control instruction with several cases, including a DEFAULT case, which corresponds to a switch case instruction.
  • FIG. 24 shows two repetitive control instructions, which correspond to a while or for slack.
  • FIG. 25 shows a mixed selective and repetitive control structure with Prologue, which corresponds to a finite automaton
  • the SELECT cases correspond to the final states of the automaton. They contain the calls to the actions that are to be carried out when an end state is reached.
  • the DEFAULT case is repetitive , leads to the reading of a new event, for example from a file, and a return to the precondition.
  • the event object is initialized in the prologue.
  • the machine table consists of a two-dimensional field with elements of class 'int', each of which corresponds to the subsequent state.
  • FIG. 26 shows a) a horizontal nesting, b) a vertical nesting and c the combination of a) and b) into a functional unit
  • FIG. 27 shows various argument, element and assignment relationships between the horizontal and the vertical nesting of a functional unit.
  • FIG. 28 shows the hierarchical arrangement of functions to modules, from modules to system levels and from system levels to an overall system.
  • the objects of higher functional units are each globally to all subordinate functional units and allow access arrows across several hierarchical levels
  • Figure 29 shows the class definition of a linked list with the name 'chain'. It includes a constructor function, as well as other functions for inserting, deleting and changing list elements.
  • the data elements of the class include one dynamic memory declaration for STRUCTURE objects of the class 'emtrag', as well as an iterator named '' first ', and the iterator' next 'serve to concatenate the list elements.
  • the element functions of' chain have access to their local objects as well as also global access to the data elements of 'chain'.
  • FIG. 30 shows an abstraction of the class definition according to FIG. 29. All details of the element functions are hidden except for their global access to the data elements. The data elements hide the details of the list objects.
  • FIG. 31 shows a coarsening of the class definition according to FIG. 29 - The traction according to FIG. 30 is hidden details, arbitrarily, the iterator is 'first' hidden, as well as all accesses of the element functions to it
  • FIG. 32 shows a class hierarchy.
  • the base class 'A' has the element functions 11 'and 12', as well as a container with an iterator as data elements.
  • the classes 'B' and 'C are derived from' A 'and each redefine the function 11' From 'C, the classes' D 'and' E 'are derived, which redefine the functions 11' and 12 'of the upper classes. All of' C
  • the visual program displayed on the screen has a memory image in the form of a complex data structure in the working memory of the programming platform.
  • This memory image is the common basis of the various functions of the programming environment, such as editing, graphic reproduction or translation into a textual programming language
  • the memory image of the visual program like the visual program itself, has a tree structure.
  • Each tree element of the visual program is assigned a memory object which is linked to other memory objects in accordance with its inclusion and neighborhood relationships, as well as its usage and communication relationships
  • the objects of the memory image are divided into classes that correspond to the different program modules.
  • the data elements of each of these classes also contain attributes that support the different functions of the programming environment, such as geometry data, color codes, classes - and object names, function names and operation symbols, arithmetic constants, documentation texts, project data and test values
  • the memory image is usually traversed recursively using virtual functions. For each visited object of the memory image, an implementation of a virtual function that is dependent on the type of the object is called up. This, depending on the type of object visited and the desired function of the programming environment, accesses attributes of the object in order to contribute to the respective function of the programming environment, such as editing or translation
  • the task of creating or changing the memory map of a visual program is achieved according to the invention in that a) that inserting, changing and deleting operations can be triggered directly in the visual program displayed on an output medium with the aid of a graphic input tool, b) that depending on the insertion, modification and deletion position within the visual program meaningfully limits the number of possible actions and inputs and this is indicated to the programmer, c) that depending on the insertion, modification and deletion position within the visual program the programmer additional auxiliary information is displayed and d) that the objects of the memory image of the visual program are enriched with information to support the method according to a) to c)
  • Cck zones are defined for each program block, into which the cursor is guided using a trackball ("mouse") and where new program modules can be inserted or existing ones can be deleted or re-specified by pressing the various buttons on the trackball (see Figure 33)
  • the program block to be inserted can be removed from an edge bar on the screen and removed from it initially.
  • a subsequent click at the insertion position leads to insertion if the block to be inserted satisfies the conditions of the insertion position For example, be type consistent or general prohibition of inserting a block type at this position.
  • help information is displayed
  • a click in the zone to label the block displays a window with permitted labels.
  • a container name only the list of available container types appears; when specifying a truss on a container, only the truss types that appear are defined for this container type, when specifying an element function only the names of those functions that are defined for this object type, etc.
  • the selection options are dependent on the previous specification. The selection of a list element is done by clicking (see Figure 34)
  • the names for operands and operations selectively offered by the editor can arise on the one hand in the course of the definition of new operands and operations on the other hand the editor can be configured with name lists that are supplied from the outside. It makes sense to automatically evaluate and classify existing class libraries of the target language using a syntax analysis
  • the specification of the assignment of a traverse to a container can also be done in "rubber-banding" technology.
  • the starting point of the cursor is the crossing point of a relationship arrow with an iterator.
  • the target point lies on the container and is released when the Key labeled with the object name of the assigned iterator.
  • the intersection of the arrow and the iterator is assigned a crossing mark
  • Each specification is immediately transferred to the memory image of the visual program. Inserting and deleting also leads to an immediate change of all dimensions and positions of the elements of the visual program concerned.At the attributes of each object of the memory image are its coordinates, its dimensions and its color The object on which the cursor is located is traversed by comparing the object coordinates with the cursor coordinates until the object under the cursor is reached.
  • FIG. 33 shows a function with two arguments and the click zones A to F, as well as a container with an iterator and elements of the STRUCTURE type with again two structure elements and the click zones A to D
  • a click is performed in zone B of the function with subsequent dragging of the cursor in zone B of an object to define an element relationship with the corresponding L-arrow.
  • a click in zone A of the function opens a window for entering the function name. If an element relationship already exists to an object, contains The window is only a list of element functions of this object.
  • a click in zone C of the function opens a window for the selection or input of constants.
  • Zone D of the function is defined for zone B in the same way as zone B, as is zone F for assignment relationships in zone A of an object leads to the opening of a window for the selection of class names or for the input of object names depending on the type of object, only the available SCALAR STRUCTURE, CONTAINER or ITERATOR classes are offered for selection If there is already an assignment between iterator and container only the iterator classes defined for this container are offered. An assignment between iterator and container is determined by a click in zone C of the crossover of iterator and reil, and then dragging the cursor into zone B of the container.
  • a click leads to zones A + B, E or F of a function for inserting the program element at the designated position Likewise, a click leads to zones A + B or D of a vertical nesting for inserting a previously determined object at the designated position.
  • a click leads to any one Position of a program element for the disappearance of the program element and when releasing the mouse button for the final deletion.
  • Figure 34 shows the graphical user interface of the editor with some visual program elements and a selection window for the specification of the traverse for a container of the class 'contl'. The selection list contains only such traverses that for the container class e 'contl' are defined
  • the task of translating the memory image of a visual program into the source code of a textual programming language is achieved according to the invention in that a) the memory image of the visual program is traversed in a traverse which corresponds to the sequential bracketed representation of the object tree, b) that for each traversed object of the memory image is called a method according to its class, which maps its attributes to syntactic elements of a target language or to administrative units of an operating system, c) that classes and subordinate functional units are translated into the source code of a target language, d) that modules and higher-level functional units are translated into administrative units of an operating system, and e) that the objects of the memory image are enriched with information to support the method according to a) to d)
  • the translation of a visual program into the source code of a textual programming language according to the procedure described here is based on a traverse that is suitable for mapping the tree structure of the memory image onto a linear bracketed structure.
  • the traverse can also be limited to individual subtrees that correspond to functional units.
  • the traverse is preferably carried out recursively, virtual methods of all object classes of the memory image being involved in the recursion
  • Class, function and operation definitions, as well as subordinate units are translated into the context-free sentence structures of the target language.
  • the object tree of the operands is either mapped to a declaration part or to data elements of a class.
  • the tree of operations is nested with function or operation calls , Printout mapped as arguments.
  • argument, element and assignment relationships are mapped to object names, element or assignment symbols.
  • Access to nested structures is assigned to wheel descriptions with possible Multiple components mapped Accesses to containers via iterators are generally mapped to a context-free compound structure
  • Sem return value is a reference to the addressed container element and can therefore be on the left (writing) as well as on the right (reading)
  • one Assignment are parameters of the O operator is an iterator from a subclass of the iterator class assigned to the respective container. The crossing mark visualizes the selection of the iterator that is used as a parameter for the Q operator.
  • General container access is therefore analogous to conventional access to field elements using the Q operator and an index value.
  • Modules, components, system levels, systems and other higher functional units, for which there is no direct counterpart in the target language, are translated into administrative units of the operating system of the target platform.
  • the source code generated from the class, function and operation definitions can thus be further structured and combined into higher functional units.
  • Such units are, for example, textual function libraries , but also so-called "header files” for merging class definitions, together with other files containing the definitions of the element functions.
  • a further hierarchical arrangement of the generated source code can be directly related to the directory map structure, whereby a suitable makefile is generated for each directory
  • Figure 35 shows a scalar object with class name 'int', object name ⁇ and initial value '0'.
  • FIG. 36 shows a structure with structure name 'datum', object name 'd' and its disclosed structural elements. Translation into “datum d,”
  • FIG. 37 shows a structure with structure name ⁇ 'emtrag' and object name 'p', the first, unspecified structure element of the type 'STRUCTURE' has been replaced by a structure of the class 'datum'.
  • Figure 38 shows a container with class name eid 'and object name' a ', which contains objects of class' type'. Translation into the template declaration "field ⁇ typ> a;”.
  • An additional size specification in the specification of the container can be mapped to another template parameter
  • Figure 39 shows a container with class names sorry 'and object names' a', which in turn contains objects of class sorry, each containing objects of class' type '. Translation into the nested template declaration "field ⁇ field ⁇ type» a ".
  • Figure 43 shows four scalar objects with the object names 'a', 'b', 'c' and 'd', as well as the call of an element operator from 'a' with the operator symbol '*'. 'b' and 'c' are input parameters of '*'. The result of the operation is assigned to 'd'.
  • Figure 45 shows four scalar objects with the object names 'a', 'b', 'c' and 'd', as well as a nested call of two functions with the names 1 'and' g '.
  • the input parameters of' g 'are' a 'and' b ' The input parameter of 1' is the result of the function call of 'g', which is additionally assigned to an object with the name 'c'
  • Figure 48 shows a container with the class name 'tree' and the object name 't ⁇ which contains objects of the class' type', as well as an iterator with class name 'itr' and object name Y The read and write access to a contamer element at the one specified by Y. Position is translated into "t [i]"
  • Figure 49 shows a container with class name eid 'and object name' a ', which contains objects of the class' tree', each of which contains objects of the class' type '.
  • An iterator with class name 'itrV and object name Y is assigned to the outer container.
  • the inner container is assigned an iterator with class name ' ⁇ tr2' and object name 'k'. Read and write access to an element of the container nesting at the position specified by Y and 'k' is translated into "a [ ⁇ ] [k]"
  • Figure 50 shows two containers with the class names' sorry 'and' tree 'and the object names' a' and 'f. 'a' contains iterator objects of class ' ⁇ tr2' which are assigned to container 't'.
  • An iterator with class name ' ⁇ tr1' and object name Y is assigned to container 'a'. Indirect read and write access to an element of container 't' at the position specified by iterator 'a [i]' is translated into "t [a [i]]"
  • FIG. 51 shows both indirect and nested access to elements of a container with object names l c4 '
  • the iterators' ⁇ 4' assigned to 'c4' are elements of container nesting 'c3' and 'c2'
  • the iterators' ⁇ 3 'and ' ⁇ 2' are elements of structures that are contained in a container with object name 'd'.
  • the iterator ' ⁇ V is assigned to this container.
  • Figure 52 shows a selective control structure with a pre- Condition that corresponds to the value of the object 'a', and a case block of the type 'SELECT', which contains a call of the function T. Translation into " ⁇ f (a) ⁇ f (x, y); ⁇ "
  • FIG. 53 shows a repetitive control structure with a prologue for initializing the pre-condition, which corresponds to the value of the object 'a', and a case block of the type 'REPEAT, which contains a call to the function' g '.
  • Figure 54 shows a selective control structure with a pre-condition that corresponds to the value of 'a' and with case blocks of different post-conditions If the pre-condition assumes the value '1', the function 'f is called. Otherwise the function 'g' is called.
  • FIG. 56 shows a mixed selective and repetitive control structure with a pre-condition that corresponds to the value of 'a' and with two case blocks of the 'REPEAT' type, after execution of which a return to the pre-condition takes place. After the execution of the 'SELECT' case block, the control structure is exited.
  • Figure 57 shows an object of the storage class' DYNAMIC with class name 'dyn' and object name 'd', which contains an object of the class' type ', and an iterator with the class name' itr 'and the object name Y.
  • the dynamic storage space allocation for an object of the class 'type' is done by calling 'new', element function of 'd'.
  • the result of the call is an iterator value that is assigned to Y.
  • Translation into " ⁇ d.neu ();”
  • the storage space is released by calling 'loschen', element function of 'd', with parameter Y. Translation into "d.loschen ( ⁇ );”.
  • Figure 58 shows the definition of a function called lunc 'There are three objects in the data part with the class names' A ',' B 'or' C, and the object names 'a', 'b' or 'c' 'b' is as Input parameters marked, 'c' is marked as input and output parameters and is changed by the function.
  • the return occurs with the terminator 'return'.
  • Figure 59 shows the definition of a class called 'X'.
  • Figure 60 shows a class named 'X' and a class derived from it called 'X' contains two data elements with the class names 'A' and 'B' and two element functions with the names 11 'and 12' 11 'is declared as virtual' Y 'contains a data element with the class name' C and the object name 'c', as well as two element functions with names 11 'and 12'.
  • ⁇ : -f1 'is a redefinition of the element function of the same name from' X 'Translation into "class X ⁇ protected: A a; B b; pubi ⁇ c: v ⁇ rtual. F1 ⁇ ... ⁇ .
  • Figure 61 shows the definition of a container called 'cont''cont' contains an object of the storage class' DYNAMIC with class name 'dyn' and object name 'd', which contains an object of class' B '.
  • the class designation 'B' is identified as a parameter of the container, 'd' is assigned an iterator of class' ttr * with object name Y for dynamic storage space management, 'cont' contains another data element called 'a', whose class designation 'A' also is marked as a parameter of 'cont''cont' is assigned an iterator for traversing with class name 'rter' and object name ' ⁇ 1' translation into "template ⁇ class A, class B> class cont ⁇ dyn ⁇ B>d; ⁇ tr ⁇ B> ⁇ ; A a, ... f ⁇ end. ⁇ ter ⁇ B> ⁇ 1 (.), ⁇ , "
  • the task of storing the memory image of a visual program in a non-volatile memory and of transporting it back to the working memory is achieved in that a) the memory image of the visual program as a related
  • the storage of the memory image of a visual program according to the method described here takes advantage of the ability of object-oriented or object-relational databases to store objects not only with their attributes, but also with all their relationships with one another, so that firstly, a quick restoration of the memory image in the Main memory is possible and secondly the integration of different development data with all their internal relationships is preserved in the long term.
  • the object-oriented database is therefore a central component of the programming environment described here
  • Various functions of the programming environment can be implemented, in whole or in part, directly through standard functions of an object-oriented or object-relational database, such as version management, statistical and archiving tasks, name management (using inverting and search functions), teamwork ( through access synchronization, locking and transaction mechanisms), integration and editing with experimental insertion (through roll-back and integration mechanisms), as well as navigation and research (through navigating and associative access mechanisms and search queries)
  • version management using inverting and search functions
  • teamwork through access synchronization, locking and transaction mechanisms
  • integration and editing with experimental insertion through roll-back and integration mechanisms
  • navigation and research through navigating and associative access mechanisms and search queries
  • the memory map of a visual program can be transferred in whole or in part from or to the database.
  • the selection of parts of the memory map can take place on the basis of topological criteria, such as when selecting a subtree, or on the basis of a Boolean search query which also contains a topologically non-contiguous set of hits
  • the selected objects can be topologically supplemented for a display and further processed in color.
  • the objects can be enriched with additional information, eg by indexing
  • the task of graphically reproducing the memory image of a visual program is solved according to the invention by a) the memory image of the visual program, in whole or in part, being reproduced in different hierarchical levels, levels of abstraction, levels of detail and scales, b) that relationships and dependencies between parts of the Memory image are highlighted graphically, c) that branching planes of the memory image are three-dimensionally layered and shown in perspective view, d) that parts of the graphic representation of the memory image are temporarily combined with parts of a foreign one Memory image are superimposed graphically and e) that the obj ects of the memory map with information in support of the method of a) to d) are enriched
  • the graphical representation of a visual program can take place in overview and detail views, which can be distributed over different windows of a graphical user interface or can be output permanently on other graphical output media. These views can be supplemented by auxiliary information, such as orientation information, labeling and documentation can be done selectively by highlighting individual parts of the system hierarchy, by applying abstractions and coarsening and by changing the level of detail and scope of the displayed system parts by changing the scale
  • the graphic representation visualizes the relationships and dependencies between the visual program elements by highlighting relevant parts or hiding non-relevant parts. Examples are the hierarchies for calling and using functions, as well as the chaining of function calls via objects and of objects via function calls result sets from topology or attribute-related search queries can be made visible.
  • the memory image can be enriched for this with suitable attributes. Further relationships result from neighborhoods with regard to a design dimension, such as error handling, the functional elements of which can be sorted and made visible according to application and system reference
  • the graphic representation also includes the visualization of the design process.
  • the basis for this is an assignment of program elements to performance features of the program.
  • the memory image must be enriched with attributes for coding performance features and for recording time stamps.
  • the programmer can be continuously shown which performance feature is edited and which program elements have previously been used for this. It is also possible to scroll through the memory image according to the time sequence of the design process according to performance characteristics.
  • the design patterns used can also be used analogously to the design process
  • All branches of the memory image that do not contain a chronological sequence can also be arranged in the form of a three-dimensional layering of functional levels and reproduced in a perspective view.
  • Further useful examples are functional units without communication via global objects such as system levels
  • parts of the graphic representation of the memory image are to be temporarily compared with parts from an external memory. image can be graphically superimposed. This allows experimentally inserting and replacing operations to be graphically supported, design alternatives compared, design patterns or reusable components fitted
  • the task of documenting the memory map of a visual program is achieved according to the invention in that a) operations for entering documentation texts, comments and other types of information can be triggered directly in the visual program displayed on a screen with the aid of a graphic input tool, b) that depending on the input position within the visual program, the documentation entered is assigned to individual program elements, c) that the documentation assigned to a program element is available locally at all times during the processing of the program, d) that the documentation of all its program units is available for each functional unit elements can be output in closed form at any time, and e) that the objects of the memory image are enriched with attributes to support the method according to a) to d)
  • the documentation of a visual program is integrated directly into the program itself and is available locally during editing or in the case of graphical reproductions.
  • the documentation assigned to the individual program elements can be extracted into an overall document for each subtree of the memory image, which is hierarchically structured according to the tree structure of the memory image Furthermore, it can be supplemented with overview or detailed representations of the visual program
  • the task of managing the memory map of a visual program is achieved according to the invention in that a) that the degree of completion of the visual program is automatically determined from the attributive and topological completeness of its memory map, b) that the development of the memory map is logged and the future course of the project the history of the creation of the memory map is determined automatically, c) that the administration of name and type information of operands and operations is carried out by standard functions of an object-relational database d) that the administration of versions, design alternatives and design patterns is carried out by Standard functions of an object-relational database are performed and e) that the objects of the memory image are enriched with information to support the method according to a) to d)
  • the project status of a visual program development can be roughly derived from the state of the memory image.
  • a container specification includes the specification of class and instance names , the specification of the container elements, an iterator, an assignment of the iterator to the container, a specification of the traverse and the name for the iterator, arrows on the container, crossing marks for arrows and iterator, accesses to the iterator, etc.
  • the completeness of the various specifications can be determined by checking the attributes and the topology of the memory image. This can also be differentiated according to levels, classes, functions, operands, operators, type and name specifications, traverses for containers Determine traction arrows, intersection marks and documentation. Compatibility can also be selected as a measure of completeness.
  • status or topology-related statistics can also be output as status information
  • the course of the project can be roughly taken from the development of the performance characteristics of the memory image.This can be logged by assigning time, person and planning data to the functional units of the memory image.
  • the memory image must be enriched with the appropriate attributes Project history are extrapolated The accuracy of the automatic estimates of project status and project history increases with increasing completeness of the memory map
  • the version management tasks can also be supported by the standard functions of the database. Analogously, the design alternatives and designs can also be managed
  • the task of navigating in the graphical representation of the memory image of a visual program is achieved according to the invention in that a) the display of the objects of the Soeicher image of the visual program proceeds in topological and associative trusses, b) that the display of the objects of the memory image changes between different levels of abstraction, levels of detail and scales, c) that a perspective display is three-dimensional orderly objects of the memory image by gradual change of direction, approach and distance, d) that auxiliary information for orientation, documentation and management is displayed and e) that the objects of the memory image are enriched with information to support the method according to a) to d)
  • the viewing of a visual program should not only take place on the standing image, but also by means of an apparent movement of the viewer through the memory image, which follows his design considerations or various functional contexts.
  • the viewing can be done in a perspective view of the functional units, especially in three dimensions. nally arranged branching levels such as for cases, threads and exceptions
  • the movement can take place in different, continuous tempos, with panning in the direction of view, approximations to details and distances. Viewing and movement can be done by changing the perspective, the level of abstraction, the level of detail and the position can also be changed by leaps and bounds.
  • the task of animating the graphical representation of the memory map of a visual program is achieved according to the invention in that functional sequences, relationships and dependencies within the visual program are highlighted by successive color or acoustic identification
  • control flow can be made clear, for example, by means of successive color coding. All the functions, operations, arrows and objects involved can be highlighted in each sequence.
  • the control flow can be animated with or without the addition of runtime values.
  • Values can be assigned to the objects of the memory image when the visual program is running using specially generated instructions, which can be played in a subsequent animation.These instructions can optionally be interspersed with the translation of the memory image into the source code.
  • the animation is determined and run by the data case automatically, whereby runtime errors are displayed at their point of origin.
  • the control flow is controlled manually by clicking Cases
  • the functions, operations, access arrows and objects involved in a program run can also be displayed simultaneously.This enables the active areas of a program to be made visible.This can be done depending on a specific data case or manually controlled by checking cases by changing the display of different ones The impact of different data traps can be compared to other areas.
  • the call and usage hierarchies are further examples of a simultaneous display of program elements. Also, sets of hits for different search queries can be compared in an alternating sequence
  • the method according to the invention allows, based on the design of integrated circuits, the application of CAD methods to the program design.
  • it is not the executable program, nor its source code, that is the actual end product of the process, but rather its visual specification. From it, the source code can be generated automatically if necessary.
  • the working basis of the engineer is, however, the visual specification according to the here in every phase of the program life cycle
  • the described method can be used to generate various graphical representations through which the engineer, according to his design or other considerations, can navigate, which he can animate and edit.
  • the specified method has the following main advantages (1)
  • the fact that dependencies between the program elements are visible makes a visual program more understandable. Unintentional dependencies are largely prevented
  • the possibility of abstraction and coarsening and through a quick change between overview - and detailed views a visual program system becomes more transparent
  • the user guidance of the visual editor makes the design faster and more reliable
  • the transition between specification and implementation is fluid, as are the transitions between the phases of the program life cycle, for which the in the object
  • the oriented memory map provides a consistent basis.
  • the specified method has the advantage that it is imperative, ie based on assignments, programming and terstutzen Since it is also object-oriented and general, it can be used as an immediate visualization of the most common programming language currently used, namely C ++

Abstract

The invention relates to a method enabling visual programming of a computer. All essential elements of an imperative, object-oriented programming language such as C++ can be visualized with the program modules cited in the invention. For example, a sorting algorithm is shown in Figure 8A. Other higher program units such as classes, modules, system planes up to overall systems can be visualized in a comprehensive, integrated overall representation. Said overall representation can be managed in an object-oriented database and can be converted into different graphic representations or also automatically into text source code if necessary. The method allows for the use of CAD development methods in the program drafts.

Description

Verfahren und System zur visuellen Programmierung Visual programming method and system
1. Anwendungsgebiet1. Field of application
Die vorliegende Erfindung betrifft ein Verfahren zur visuellen Programmierung sowohl von Algo- rithmen, als auch von übergeordneten Programmeinheiten, welches verschiedene Phasen des Programm-Lebenszyklus dadurch unterstützt, daß es Abhängigkeiten und Beziehungen innerhalb eines Programmsystems visualisiert, d.h. sichtbar macht. Das Verfahren soll die textuelle Programmierung mit ihren in dieser Hinsicht bekannten Nachteilen ersetzen.The present invention relates to a method for the visual programming of both algorithms and of higher-level program units, which supports different phases of the program life cycle by visualizing dependencies and relationships within a program system, i.e. makes visible. The method is intended to replace textual programming with its known disadvantages in this regard.
2. Stand der Technik2. State of the art
Dem heutigen Stand der Softwaretechnik liegt weitgehend die Annahme zugrunde, daß textueile Programmiersprachen ohne Alternative sind. Dies zeigen die Verbreitung der Programmiersprachen in der industriellen Praxis, aber auch fortgesetzte Neuentwicklungen von Sprachen. In sogenannten Programming Workbenches zur fortschrittlichen, computer-gestützten Programmierung spielen Compiler, die programmiersprachlichen Quellcode in Maschinencode transformieren, nach wie vor eine zentrale Rolle, wenn auch der Programmierer nicht mehr direkt mit dem Quellcode in Berührung kommt, sondern stattdessen meist mithilfe eines Struktur-Editors den Abstrakten Syntaxbaum des Programms editiert (siehe S.532 in lan Sommerville: "Software Engineering", Addi- son-Wesiey, 5. Auflage, 1996).The current state of software technology is largely based on the assumption that textile programming languages have no alternative. This shows the spread of programming languages in industrial practice, but also the continued development of new languages. In so-called programming workbenches for advanced, computer-aided programming, compilers that transform programming language source code into machine code continue to play a central role, even if the programmer no longer comes into direct contact with the source code, but instead usually with the help of a structure editor edited the abstract syntax tree of the program (see p.532 in Lan Sommerville: "Software Engineering", Addison-Wesiey, 5th edition, 1996).
In der Patentliteratur sind folgende Varianten dieser computer-gestützten textuellen Kodierungsverfahren vertreten (Stand 29. Januar 1998). Ein Verfahren für die direkte Manipulation des Abstrakten Syntaxbaumes wird beispielsweise angegeben in Microsoft: "Method and System for ge- nerating a Computer Program", EP 00651325 (1994). Der Struktur- Editor wird hierbei über Kom- mandos bedient, die von der Zielsprache unabhängig sind. Ein Verfahren, das den Gesamtentwurf unterstützt, ist beschrieben in Hitachi: "Verfahren zum automatischen Erzeugen eines Quellenprogramms", DE 3503119 (1985). Hierbei werden separate Diagramme für die Modulstruktur, den Prozeßfluß und die Daten erstellt, die unmittelbar und automatisch in Quellcode umgesetzt werden. In Hitachi: „Visual Programming Method", US 5664129 (1997), werden Operations- und Operandennamen aus einer Übersichtsanzeige entnommen und tabellarisch zu einem Programm zusammengefügt. In der Programmtabelle werden Ausgabewerte von Operationen als Eingabewerte darauffolgender Operationen durch Linienverbindungen visualisiert. Die Beschreibung der Datentypen erfolgt textuell. Aus der Programmtabelle kann direkt textueller Quellcode erzeugt werden. Verfahren, die den Gesamtentwurf durch die Generierung von Schablonen unterstützen, die anschließend manuell weiterzuverarbeiten sind, sind IBM: "Object-oriented System for genera- ting Target Language Code", EP 00706125 (1995), Honda: "Method for generating a Program", EP 00696000 (1995) und AT&T: "System for generating Software Source Code Components", EP 00219993. Schließlich existieren Verfahren, traditionell hergestellte Software nachträglich durch automatisch generierte Diagramme und Statistiken transparent zu machen, z.B. AT&T: "Method and Apparatus for displaying hierarchical Information of a large Software System", EP 00650118 (1994) und AT&T: "Apparatus for visualizing Program Slices", EP ' 00714064 (1995). Ein Verfahren, ein Programm zur Laufzeit durch Monitoring der Objekte transparent zu machen, ist beschrieben in IBM: "Visualizing object-oriented Software", EP 00689132 (1995). Diesen Verfahren ist gemeinsam, daß sie die traditionelle textuelle Programmierung unterstützen, sie aber nicht durch visuelle Methoden ablösen.The following variants of these computer-aided textual coding methods are represented in the patent literature (as of January 29, 1998). A method for the direct manipulation of the abstract syntax tree is given, for example, in Microsoft: "Method and System for generating a Computer Program", EP 00651325 (1994). The structure editor is operated via commands that are independent of the target language. A method that supports the overall design is described in Hitachi: "Method for automatically generating a source program", DE 3503119 (1985). This creates separate diagrams for the module structure, the process flow and the data, which are immediately and automatically converted into source code. In Hitachi: "Visual Programming Method", US 5664129 (1997), operation and operand names are taken from an overview display and combined into a program in a table. In the program table, output values of operations are visualized as input values for subsequent operations by line connections. The description of the data types Textual source code can be generated directly from the program table. Methods that support the overall design by generating templates that can subsequently be further processed are IBM: "Object-oriented System for generating Target Language Code", EP 00706125 (1995), Honda: "Method for generating a program", EP 00696000 (1995) and AT&T: "System for generating software source code components", EP 00219993. Finally, there are methods, software that has been traditionally produced retrospectively by automatically generated diagrams and statistics to do, e.g. AT&T: "Method and Apparatus for displaying hierarchical information of a large software system ", EP 00650118 (1994) and AT&T:" Apparatus for visualizing Program Slices ", EP ' 00714064 (1995). A method of making a program transparent at runtime by monitoring the objects , is described in IBM: "Visualizing object-oriented software", EP 00689132 (1995). These methods have in common that they support traditional textual programming but do not replace them by visual methods.
Voll visualisierte Programmiermethoden gibt es für einige eingeschränkte Anwendungsbereiche, wie z.B. für die Spezifikation von Entscheidungsbäumen oder von ähnlichen hierarchischen Struk- turen. In Ford: „Verfahren und System zur Verarbeitung und On-Line-Darstellung von Multimedia- Information in einer Baumstruktur", DE 4332193 A1 , wird mit rein graphischen Mitteln („rubber- banding") ein Entscheidungsbaum editiert, der die Maschinendiagnose mittels Frage-Antwort-Verzweigung unterstützt. Ebenfalls graphisch („drag-and-drop") wird das Diagnosewissen in Form von Texten, Graphiken, Videos etc. den Knoten des Entscheidungsbaumes zugeordnet. In Bell: „Vi- sual Programming of Telephone Network Call Processing Logic", WO 92/11724, wird mittels einer graphischen Benutzeroberfläche eine Baumstruktur editiert, welche die Dienstelemente eines hierarchisch strukturierten Telekommunikationsdienstes sowie deren Ausführungsreihenfolge wiedergibt. Der Dienst kann anschließend ausgeführt werden, indem die zuvor erzeugte Baumstruktur automatisch interpretiert wird. Derartige Verfahren, die ein Programmieren im weiteren Sinne beinhalten, werden typischerweise für Konfigurationsaufgaben eingesetzt. Sie besitzen im Allgemeinen nicht die Möglichkeit, Operationen und Operanden frei zu definieren und diese dann innerhalb eines Kontrollflusses frei miteinander zu verknüpfen. Sie sind daher auch nicht geeignet, textuelle Programmiersprachen zu ersetzen.Fully visualized programming methods are available for some restricted areas of application, e.g. for the specification of decision trees or similar hierarchical structures. In Ford: "Method and system for processing and on-line display of multimedia information in a tree structure", DE 4332193 A1, a decision tree is edited using purely graphical means ("rubber banding"), which the machine diagnosis by means of questions Answer branch supported. The diagnostic knowledge in the form of texts, graphics, videos, etc. is also assigned graphically (“drag-and-drop”) to the nodes of the decision tree. In Bell: “Visual Programming of Telephone Network Call Processing Logic”, WO 92/11724 , a tree structure is edited by means of a graphical user interface, which shows the service elements of a hierarchically structured telecommunication service and their execution sequence. The service can then be executed by automatically interpreting the tree structure previously created. Such methods, which include programming in a broader sense, are typically used for configuration tasks. In general, you do not have the option of freely defining operations and operands and then freely linking them together within a control flow. They are therefore not suitable for replacing textual programming languages.
Seit Anfang der achtziger Jahre gibt es dagegen Bestrebungen einer Minderheit von Software-Ingenieuren, Programmiersprachen zu visualisieren und damit anschaulich zu machen. So entstand der Bereich der "Visuellen Programmiersprachen und Programmierumgebungen". Auch das erfindungsgemäße Verfahren ist diesem Bereich zuzuordnen. Eine Übersicht zum Stand der Technik bis einschließlich Februar 1996 ist zu finden in Jörg Poswiα: "Visuelle Programmierung - Compu- terprogramme auf graphischem Weg erstellen", Hanser-Verlag, 1996. Eine laufend aktualisierte Bibliographie aller wesentlichen, in internationalen Fachzeitschriften veröffentlichten Forschungsarbeiten zum Thema "Visuelle Programmierverfahren" führt das im Academic-Press-Verlag, London, erscheinende Journal of Visual Languages and Computing (Web-Dokument http://www. cs.orst.edu/~burnett/vDl.html). Nach dem Klassifizierungsschema, das dieser Bibliographie zu- grundeliegt, kann das erfindungsgemäße Verfahren den Merkmalen "VPL-II.A.6 imperative" und "VPL-V.A general-purpose" zugeordnet werden. Diese Merkmalskombination weist keines der dort angeführten Verfahren auf (Stand 16. Februar 1998).In contrast, since the beginning of the 1980s, a minority of software engineers have attempted to visualize programming languages and thus to make them clear. This is how the area of "Visual Programming Languages and Programming Environments" came into being. The method according to the invention can also be assigned to this area. An overview of the state of the art up to and including February 1996 can be found in Jörg Poswiα: "Visual programming - creating computer programs graphically", Hanser-Verlag, 1996. A continuously updated bibliography of all major research papers on the topic published in international journals "Visual programming methods" is published in the Journal of Visual Languages and Computing published by Academic-Press-Verlag, London (web document http: // www. Cs.orst.edu/~burnett/vDl.html). According to the classification scheme on which this bibliography is based, the method according to the invention can be assigned to the features "VPL-II.A.6 imperative" and "VPL-V.A general-purpose". This combination of features does not have any of the methods listed there (as of February 16, 1998).
Besondere Bedeutung für die Praxis hat die Kategorie der "imperativen Sprachen" (VPL-II.A.6), die auf dem Zuweisungs- und Kontrollflußprinzip beruhen und in der Lage wären, praxisrelevanteThe category of "imperative languages" (VPL-II.A.6), which are based on the allocation and control flow principle and which would be able to practice, is of particular importance for practice
Programmiersprachen wie C und C++ zu visualisieren. In dieser Kategorie werden lediglich meh- rere Arbeiten zur Graphmanipulationssprache PROGRES angeführt, z.B. Andreas Schuerr: "PRO- GRES: A VHL-Language Based on Graph Grammars", Lecture Notes in Computer Science 532, Springer- Verlag (1991), S. 641-659. Graph-basierte Sprachen sind grundsätzlich auf bestimmte Anwendungsbereiche beschränkt und damit nicht „universell".Visualize programming languages such as C and C ++. In this category, only several More work on the graph manipulation language PROGRES is given, e.g. Andreas Schuerr: "PROGRES: A VHL-Language Based on Graph Grammars", Lecture Notes in Computer Science 532, Springer-Verlag (1991), pp. 641-659. Graph-based languages are fundamentally restricted to certain areas of application and are therefore not "universal".
In der Gruppe der "universellen Sprachen" (VPL-V.A) dominieren die Datenfluß-Verfahren (VPL- II.A.3) mit ihrer jeweiligen Visualisierung des unterliegenden Datenflußgraphen, z.B. Braine. L, Clack, C: "Object-Flow", in 1997 IEEE Symposium on Visual Languages, Capri, Italy, Sept. 1997. Im Gegensatz zu den imperativen Sprachen, stellen die Datenflußsprachen keine syntaktischen Elemente zur Sequentialisierung von Anweisungen zur Verfügung und entfernen sich daher sehr von dem in der Praxis üblichen Programmierstil. Die Akzeptanz der textuellen Datenflußsprachen für den professionellen Einsatz ist entsprechend gering. Ein visuelles Verfahren dieser Art, das dennoch eine gewisse praktische Bedeutung erlangt hat, ist das kommerziell vertriebene Entwicklungswerkzeug "PROGRAPH CPX" (siehe [Poswig]).In the group of "universal languages" (VPL-V.A) the data flow methods (VPL-II.A.3) dominate with their respective visualization of the underlying data flow graph, e.g. Braine. L, Clack, C: "Object-Flow", 1997 IEEE Symposium on Visual Languages, Capri, Italy, Sept. 1997. In contrast to the imperative languages, the data flow languages do not provide any syntactic elements for the sequentialization of instructions and are removed therefore very much from the programming style common in practice. The acceptance of the textual data flow languages for professional use is correspondingly low. A visual process of this kind, which has nevertheless gained a certain practical importance, is the commercially available development tool "PROGRAPH CPX" (see [Poswig]).
Weitere Verfahren, die in der Gruppe der "universellen Sprachen" (VPL-V.A) aufgeführt werden, sind die "funktionalen Sprachen" (VPL-II.A.5), die große Ähnlichkeit mit den Datenflußsprachen besitzen, insbesondere, was die Abwesenheit des Kontrollflusses betrifft. In der Praxis konnten sie sich als textuelle Verfahren im Allgemeinen nicht durchsetzen (Ausnahme LISP). Gegenstand der Visualisierung ist hier jeweils die Ein-Ausgabe-Relation einer Funktion. Siehe beispielsweise Er- wiα, M.: "DEAL - A Language for Depicting Algorithms", in IEEE Symposium on Visual Languages, St. Louis, USA, Oct. 1994.Other methods that are listed in the group of "universal languages" (VPL-VA) are the "functional languages" (VPL-II.A.5), which are very similar to the data flow languages, especially in terms of the absence of Control flow concerns. In practice, they were generally unable to establish themselves as textual processes (exception: LISP). The visualization here deals with the input-output relation of a function. See, for example, Erwiα, M .: "DEAL - A Language for Depicting Algorithms", in IEEE Symposium on Visual Languages, St. Louis, USA, Oct. 1994.
Die in der Gruppe der "universellen Sprachen" (VPL-V.A) aufgeführten "logischen Sprachen" (VPL-II.A.7) basieren auf der Implikation und der Anwendung von Schlußregeln. Gegenstand der Visualisierung sind hier logische Ausdrücke und ihre Transformation. Siehe beispielsweise Aαusti, J. et al.: "Towards Specifying with Inclusions", in Mathware and Soft Computing, 1997. Wie im Fall der "funktionalen Sprachen" handelt es sich hier um Sprachen, die sich einerseits als textuelle Verfahren in der Praxis nicht durchsetzen konnten (Ausnahme Prolog) und deren Visualisierungen sich andererseits noch weitgehend im Experimentierstadium befinden.The "logical languages" (VPL-II.A.7) listed in the group of "universal languages" (VPL-V.A) are based on the implication and application of inference rules. The visualization here deals with logical expressions and their transformation. See, for example, Aαusti, J. et al .: "Towards Specifying with Inclusions", in Mathware and Soft Computing, 1997. As in the case of "functional languages", these are languages which, on the one hand, do not exist in practice as textual processes prevailed (exception prologue) and their visualizations are still largely in the experimental stage.
In der Gruppe der "universellen Sprachen" (VPL-V.A) sind weiterhin "formular- und tabellen-ba- sierte" (VPL-II.A.4) Verfahren vertreten, siehe z.B. DuPuis. C. Burnett, M.: "An Animated Turing Machine Simulator in Forms/3", Oregon State University, Dept. of Computer Science, TR 97-60- 08, July 1997. In dieser Arbeit wird gezeigt, daß "Forms/3" ein universelles Verfahren ist, jedoch darauf hingewiesen, daß dies nicht für die bisher kommerziell verwerteten Verfahren gilt.In the group of "universal languages" (VPL-V.A) "form and table-based" (VPL-II.A.4) procedures are still represented, see e.g. DuPuis. C. Burnett, M .: "An Animated Turing Machine Simulator in Forms / 3", Oregon State University, Dept. of Computer Science, TR 97-60-08, July 1997. In this work it is shown that "Forms / 3" is a universal process, but it is pointed out that this does not apply to the processes which have been used commercially until now.
Zusammenfassend kann zum Stand der Technik festgestellt werden, daß es sich bei den bekannten visuellen oder graphisch unterstützten Programmiermethoden um stark eingeschränkte Ver- fahren handelt, entweder hinsichtlich ihrer Visualisierung oder hinsichtlich ihres Anwendungsbereichs. Bei den in der Praxis eingesetzten Verfahren, welche die textuelle Programmierung unter- stützen, gilt hinsichtlich ihrer Visualisierung, (1) daß jeweils unterschiedliche und separate Baumdarstellungen für Algorithmen, Datenstrukturen, Modulstrukturen, Vererbungsbeziehungen, usw. benutzt werden, (2) daß für Datenstrukturen separate Baumdarstellungen benutzt werden, wobei Visualisierungen für das Traversieren komplexer Datenstrukturen gänzlich fehlen und (3) daß Beziehungen zwischen funktionalen Einheiten und Datenstrukturen in der Regel nicht visuell, sondern über Namensverweise ausgedrückt werden. Die wissenschaftlich orientierten visuellen Verfahren konzentrieren sich im Wesentlichen auf Bereiche mit naheliegender Visualisierung, wie z.B. für Datenfluß, Graphmanipulation und Mengendiagramm. Die imperative Programmierung wird dagegen wegen der ihr innewohnenden Notwendigkeit der Zeigerprogrammierung weitgehend ausgeklammert. Entsprechend fehlen auch hier Ansätze beispielsweise zur Visualisierung von Traversen auf komplexen Datenstrukturen. Bezeichnend für den Stand der Softwaretechnik ist daher, daß praktisch einsetzbare integrierte visuelle Gesamtdarstellungen für Programmsysteme bis heute fehlen.In summary, it can be stated in relation to the prior art that the known visual or graphically supported programming methods are severely restricted methods, either with regard to their visualization or with regard to their area of application. In the processes used in practice, which support the textual programming with regard to their visualization, (1) that different and separate tree representations are used for algorithms, data structures, module structures, inheritance relationships, etc., (2) that separate tree representations are used for data structures, whereby visualizations for traversing complex data structures are completely absent and (3) that relationships between functional units and data structures are usually not expressed visually, but by name references. The scientifically oriented visual processes mainly focus on areas with obvious visualization, such as for data flow, graph manipulation and quantity diagram. In contrast, imperative programming is largely excluded because of the inherent need for pointer programming. Accordingly, approaches to visualize trusses on complex data structures are also missing here. It is therefore characteristic of the state of software technology that there are still no practical, integrated overall visual representations for program systems.
Der Erfindung liegt daher die Aufgabe zugrunde, die bisherigen visuellen Programmierverfahren dahingehend zu verbessern, (1) daß die visuelle Programmierung nicht auf einen speziellen Anwendungsbereich beschränkt ist, (2) daß die in der Praxis bewährten Paradigmen der textuellen Programmierung, wie imperativer und objektorientierter Programmierstil, beibehalten werden, (3) daß die Visualisierung vollständig ist und sowohl den Kontrollfluß, als auch die Struktur der Opera- tionen und Operanden sowie die Traversierung komplexer Operanden umfaßt und (4) daß die Visualisierung einheitlich ist, indem sie ein visuelles Programm in einer einzigen Graphik unter Verwendung einer einheitlichen Struktur darzustellen erlaubt.The invention is therefore based on the object of improving the previous visual programming methods in such a way that (1) that the visual programming is not restricted to a specific area of application, (2) that the paradigms of text programming, such as imperative and object-oriented programming style, which have proven themselves in practice , (3) that the visualization is complete and encompasses both the control flow, the structure of the operations and operands and the traversal of complex operands, and (4) that the visualization is uniform by using a visual program in one single graph can be displayed using a uniform structure.
3. Technisches Vorurteil3. Technical prejudice
Nach Aussagen in [Poswig] "haben visuelle Sprachen allgemein nicht die theoretische Mächtigkeit einer universellen Programmiersprache" (S.32) und sollten diesen Anspruch auch nicht hegen, denn "visuelle Programmiersprachen sind nur dann erfolgreich, wenn sie speziell für einen Anwendungsbereich ausgelegt sind" (S. 42). Diagramm-basierte visuelle Programmierung - das ist jene, um die es bei der vorliegenden Erfindung geht - hat meist als Grundlage die sogenannten Nassi-Shneiderman-Diagramme oder Flußdiagramme, doch wird dieser Zweig der Programmierung mit visuellen Ausdrücken als bedeutungslos angesehen (S.33). Darüberhinaus wird es "als extremer Standpunkt gewertet, eine textuelle Programmiersprache direkt in ein graphisches Gegenstück umzusetzen" (S.53). Deshalb "sollte man bei der Entwicklung einer visuellen Program- miersprache nicht versuchen, eine textuelle Sprache eins zu eins zu visualisieren" (S.66).According to statements in [Poswig] "visual languages generally do not have the theoretical power of a universal programming language" (p.32) and should not have this claim, because "visual programming languages are only successful if they are specially designed for an area of application" (P. 42). Diagram-based visual programming - this is what the present invention is about - is mostly based on the so-called Nassi-Shneiderman diagrams or flowcharts, but this branch of programming with visual expressions is considered to be meaningless (p.33) . In addition, it is "considered an extreme point of view to translate a textual programming language directly into a graphic counterpart" (p.53). Therefore "when developing a visual programming language one should not try to visualize a textual language one to one" (p.66).
Es hat sich nun überraschenderweise gezeigt, daß sich - entgegen den zitierten Expertenmeinungen - alle wesentlichen Elemente einer textuellen objekt-orientierten Programmiersprache (hier gezeigt am Beispiel von C++) auf einfache graphische Elemente abbilden lassen, die zu einer inte- grierten Gesamtdarstellung eines Softwaresystems zusammengefügt und daraus automatisch in objekt-orientierten Quellcode übersetzt werden können. Insbesondere können dabei (1) die in textuellen Programmiersprachen syntaktisch uneinheitlichen Baumstrukturen von z.B. arithmetischlogischen Ausdrücken, verschachtelten Blockstrukturen, Funktions-, Klassen- und Vererbungshierarchien, Modul-, Komponenten- und Ebenenhierarchien auf einheitliche Weise (hier gezeigt anhand einer Terrassendarstellung für Bäume) und durchgängig vom Funktionsargument bis hin zum Gesamtsystem dargestellt werden. Ebenso ist es möglich, (2) mit denselben graphischen Mitteln wie in (1) auch die Operanden zu erfassen, und zwar sowohl unter dem Gesichtspunkt der Strukturierung, als auch unter dem der Traversierung, als auch unter dem des differenzierten Zugriffs in Form von Argument-, Zuweisungs- und Elementbeziehungen. Auch Gültigkeitsbereich und Lebensdauer können dargestellt werden. Schließlich können (3) die Beziehungen durch eine gitterartige Verknüpfung der beiden Baumstrukturen nach (1) und (2) visualisiert werden, sodaß sich für das Gesamtsystem eine Art "integriertes Schaltbild" mit Chip-Charakter ergibt. Neben den Merkmalen „VPL-V.A general-purpose" und „VPL-II.A.6 imperative" besitzt das erfindungsgemäße Verfahren folgende weitere Merkmale nach dem Klassifizierungsschema des Journal of Visual Languages and Computing: „VPL-II.A.9 object oriented", „VPL-II.B.1 diagrammatic", „VPL-II.A abstraction (data, procedural)", „VPL-III.B control flow", „VPL.III.C data types and structures", „VPL-III.D documentation" und „VPL-III.F exception handling".It has now surprisingly been found that - contrary to the expert opinions cited - all essential elements of a textual object-oriented programming language (shown here using the example of C ++) can be mapped onto simple graphic elements which are combined to form an integrated overall representation of a software system and from it automatically in object-oriented source code can be translated. In particular, (1) the tree structures of e.g. arithmetic-logical expressions, nested block structures, function, class and inheritance hierarchies, module, component and level hierarchies, which are syntactically inconsistent in textual programming languages, can be used in a uniform manner (shown here using a terrace representation for trees) and consistently from the functional argument to the overall system. It is also possible to (2) capture the operands using the same graphic means as in (1), both from the point of view of structuring and traversing, as well as from the point of view of differentiated access in the form of an argument -, assignment and element relationships. The scope and lifespan can also be shown. Finally, (3) the relationships can be visualized by a grid-like connection of the two tree structures according to (1) and (2), so that a kind of "integrated circuit diagram" with chip character results for the overall system. In addition to the features “VPL-VA general-purpose” and “VPL-II.A.6 imperative”, the method according to the invention has the following further features according to the classification scheme of the Journal of Visual Languages and Computing: “VPL-II.A.9 object oriented "," VPL-II.B.1 diagrammatic "," VPL-II.A abstraction (data, procedural) "," VPL-III.B control flow "," VPL.III.C data types and structures "," VPL-III.D documentation "and" VPL-III.F exception handling ".
4. Erfindungsdarlegung4. Presentation of the invention
Die Aufgabe, einen Rechner visuell zu programmieren, wird erfindungsgemäß dadurch gelöst, a) daß die Operationen, bestehend aus einfachen und ineinander verschachtelten Funktions- und Operationsaufrufen mit ihren Argumenten, gemäß ihren Nachbarschafts- und Inklusionsbeziehungen zueinander, durch eine erste Baumstruktur visualisiert werden, b) daß die Operanden, besteh- end aus einfachen und ineinander verschachtelten Objekten und Datenstrukturen, gemäß ihren Nachbarschafts- und Inklusionsbeziehungen zueinander, durch eine zweite Baumstruktur visualisiert werden, und c) daß die Beziehungen zwischen den Operationen einerseits und den Operanden andererseits, bestehend aus Argument-, Zuweisungs-, Element- und anderen Beziehungen, durch Linienverbindungen zwischen Elementen der ersten Baumstruktur und Elementen der zweiten Baumstruktur visualisiert werden.The task of programming a computer visually is achieved according to the invention in that a) the operations, consisting of simple and interleaved function and operation calls with their arguments, are visualized by a first tree structure in accordance with their neighborhood and inclusion relationships, b ) that the operands, consisting of simple and nested objects and data structures, are visualized by a second tree structure in accordance with their neighborhood and inclusion relationships, and c) that the relationships between the operations on the one hand and the operands on the other hand, consisting of argument -, assignment, element and other relationships can be visualized by line connections between elements of the first tree structure and elements of the second tree structure.
5. Beschreibung5. Description
5.1 Allgemeines5.1 General
Wesentliches Ziel des Verfahrens ist die Visualisierung von (1) Nachbarschafts- und Enthalten- seinsbeziehungen einerseits und von (2) Benutzungs- oder Kommunikationsbeziehungen andererseits. Dabei spielen Formen, Farben, Winkel und Abmessungen der benutzten Geometrie eine untergeordnete Rolle. Verschiedene geometrische Ausführungen sind denkbar. Hier wird exem- plarisch für die Visualisierung von Beziehungen nach (1) eine Terrassendarstellung für Baum- Strukturen gewählt, die aufgrund ihrer Kompaktheit vorteilhaft erscheint. Die Beziehungen nach (2) werden, ebenfalls exemplarisch, durch eine Gitterstruktur visualisiert, die wegen ihrer Übersichtlichkeit bevorzugt wird. Darüberhinaus ist das Verfahren unabhängig von der Zielsprache, in welche die visuellen Programmelemente automatisch übersetzt werden können. Grundsätzlich ist die Übersetzung direkt in den Maschinencode eines konkreten Prozessors möglich. Hier wird als Zielsprache exemplarisch die objekt-o entierte Programmiersprache C++ gewählt, die aufgrund des Abbildungsmaßstabes und der Portabilität vorteilhaft erscheint. Weiterhin ist die hier getroffene Auswahl der Programmbausteine willkürlich. Das Verfahren ist ebenso anwendbar auf einen erweiterten oder eingeschränkten Satz von Programmelementen. Hier werden exemplarisch Bau- steine ausgewählt, die einerseits für den Programmieralltag sinnvoll erscheinen, andererseits die Mächtigkeit des visuellen Verfahrens zeigen.The main aim of the method is to visualize (1) neighborhood and abstinence relationships on the one hand and (2) usage or communication relationships on the other. The shapes, colors, angles and dimensions of the geometry used play a subordinate role. Different geometrical designs are conceivable. Here, as an example for the visualization of relationships according to (1), a terrace representation for tree Structures selected that appear advantageous due to their compactness. The relationships according to (2) are visualized, likewise by way of example, by a lattice structure, which is preferred for its clarity. In addition, the process is independent of the target language into which the visual program elements can be automatically translated. In principle, translation is possible directly into the machine code of a specific processor. The object-oriented programming language C ++ is chosen here as the target language, which appears advantageous due to the scale and portability. Furthermore, the selection of program modules made here is arbitrary. The method is also applicable to an expanded or restricted set of program elements. Here, as an example, building blocks are selected that on the one hand appear useful for everyday programming, and on the other hand show the power of the visual process.
5.2 Graphische Grundelemente5.2 Basic graphic elements
An graphischen und textuellen Grundelementen für das Verfahren werden benötigt:The following are required for graphic and textual basic elements for the process:
Rechtecke (Typ H), die in horizontaler sequentieller Anordnung weitere Rechtecke des Typs H enthalten können, sowie selbst wieder in horizontaler sequentieller Anordnung in anderen Rechtecken des Typs H enthalten sein können. Die Anordnung soll disjunkt sein und festgelegte horizontale Abstände einhalten. Die Höhe und Breite der Rechtecke soll von der Höhe und Breite der darin enthaltenen Rechtecke abhängen und dabei festgelegte Randabstände einhalten. Die Abstände sollen so gewählt sein, daß einerseits eine gewisse Kompaktheit der Gesamtstruktur gegeben ist, andererseits die erhaltene Klammerstruktur ausreichend visualisiert ist. Die so erhaltene Anordnung wird „horizontale Verschachtelung" genannt. Die beteiligten Rechtecke nennen wir „H-Boxen". H-Boxen einer minimalen, definierten Größe, die selbst keine weiteren H-Boxen enthalten, nennen wir „atomare H-Boxen" (siehe Figur 1). Rechtecke (Typ V). die in vertikaler sequentieller Anordnung weitere Rechtecke des Typs V ent- halten können, sowie selbst wieder in vertikaler sequentieller Anordnung in anderen Rechtecken des Typs V enthalten sein können. Die vertikalen Abstände, sowie die Berandung soll analog zur horizontalen Verschachtelung vorgenommen werden. Die so erhaltene Anordnung wird „vertikale Verschachtelung" genannt. Die beteiligten Rechtecke nennen wir „V-Boxen". V-Boxen einer minimalen, definierten Höhe, die selbst keine weiteren V-Boxen enthalten, nennen wir „atomare V- Boxen". V-Boxen werden horizontal gedehnt dargestellt. Ihre Breite hängt ab von der Breite einer ihnen zugeordneten horizontalen Verschachtelung (siehe Figur 2).Rectangles (type H), which can contain further type H rectangles in a horizontal sequential arrangement, and can themselves be contained again in other type H rectangles in a horizontal sequential arrangement. The arrangement should be disjoint and maintain fixed horizontal distances. The height and width of the rectangles should depend on the height and width of the rectangles they contain and should adhere to fixed edge distances. The distances should be chosen so that on the one hand there is a certain compactness of the overall structure, on the other hand the bracket structure obtained is sufficiently visualized. The arrangement obtained in this way is called "horizontal nesting". We call the rectangles involved "H-boxes". H-boxes of a minimal, defined size, which themselves do not contain any further H-boxes, we call "atomic H-boxes" (see FIG. 1). Rectangles (type V). Which, in a vertical, sequential arrangement, contain further rectangles of type V can hold, as well as can be contained again in a vertical sequential arrangement in other rectangles of type V. The vertical spacing and the border should be carried out analogously to the horizontal nesting. The arrangement obtained in this way is called "vertical nesting". We call the rectangles involved "V-boxes". V-boxes of a minimum, defined height, which themselves do not contain any further V-boxes, we call "atomic V-boxes". V-boxes are shown horizontally stretched. Their width depends on the width of a horizontal nesting assigned to them (see FIG. 2).
Rechtecke (Typ E). die in vertikaler sequentieller Anordnung genau eine horizontale Verschachtelung und darunter genau eine (eventuell leere) vertikale Verschachtelung enthalten. Derartige Rechtecke nennen wir „Einheiten". Die Breite der innersten V-Boxen der vertikalen Verschachte- lung einer Einheit entspricht dabei der Breite der darüberliegenden horizontalen Verschachtelung dieser Einheit. Jede Einheit soll selbst wieder H-Box sein, sodaß Einheiten in der horizontalen Verschachtelung einer übergeordneten Einheit auftreten können. Eine solche Anordnung von Einheiten nennen wir „Hierarchie" (siehe Figur 3). Linien, die H-Boxen der horizontalen Verschachtelung einer Einheit mit V-Boxen der vertikalen Verschachtelung derselben oder einer übergeordneten Einheit in vertikaler Ausrichtung verbinden. Diese Linien können am oberen oder unteren Ende oder an beiden Enden mit Pfeilspitzen versehen sein. Derartige Linien nennen wir „Pfeile". Pfeile treffen eine V-Box jeweils von oben und enden an ihrer Oberkante. Eine V-Box kann an jedem Punkt der Oberkante getroffen werden. Eine H-Box wird von unten getroffen und endet am linken oder am rechten Ende ihrer Unterkante. Einen Pfeil am linken Ende nennen wir „L-Pfeil", einen Pfeil am rechten Ende nennen wir „R-Pfeil". Eine atomare H-Box wird nur in der Mitte ihrer Unterkante getroffen (siehe Figur 4). Kreise mit kleinem Durchmesser, die ausgewählte Überkreuzungen von Pfeilen mit atomaren V- Boxen überdecken. Derartige Kreise nennen wir „Kreuzungsmarken" (siehe Figur 5).Rectangles (type E). that contain exactly one horizontal nesting in a vertical sequential arrangement, and underneath exactly one (possibly empty) vertical nesting. We call such rectangles "units". The width of the innermost V-boxes of the vertical nesting of a unit corresponds to the width of the horizontal nesting above this unit. Each unit should itself be an H-box again, so that units in the horizontal nesting one superordinate unit can occur. We call such an arrangement of units "hierarchy" (see FIG. 3). Lines connecting H-boxes of the horizontal nesting of a unit with V-boxes of the vertical nesting of the same or a higher-level unit in a vertical orientation. These lines can be provided with arrowheads at the upper or lower end or at both ends. We call such lines "arrows". Arrows hit a V-box from above and end at its top edge. A V-box can be hit at any point on the top edge. An H-box is hit from below and ends on the left or on right end of its lower edge. An arrow at the left end we call "L-arrow", an arrow at the right end we call "R-arrow". An atomic H-Box is only hit in the middle of its lower edge (see Figure 4). Small diameter circles covering selected crossings of arrows with atomic V-boxes. We call such circles "crossing marks" (see FIG. 5).
Alpha-numerische Zeichenketten, mit denen H-Boxen und V-Boxen - in der Regel in der linken oberen Ecke - beschriftet werden. Derartige Zeichenketten nennen wir „Namen". Eine Beschriftung kann zum Zwecke der Übersichtlichkeit der restlichen Darstellung auch teilweise verdeckt werden (siehe Figur 6). Sonderzeichen, mit denen H-Boxen, in der Regel in der linken oberen Ecke, beschriftet werden. Ein oder mehrere solcher Sonderzeichen einer Beschriftung nennen wir „Symbol". Symbole werden gelegentlich auch zur Kennzeichnung von V-Boxen benutzt (siehe Figur 7).Alpha-numeric strings that are used to label H-boxes and V-boxes - usually in the upper left corner. We call such character strings "names". A label can also be partially covered for the sake of clarity of the rest of the representation (see Figure 6). Special characters with which H-boxes, usually in the upper left corner, are labeled. One or We call several such special characters of a label "symbol". Symbols are occasionally also used to identify V-boxes (see Figure 7).
Beispiele für graphische GrundelementeExamples of basic graphic elements
Figur 1 zeigt eine horizontale Verschachtelung (1) mit atomaren H-Boxen (2) und nicht-atomarenFigure 1 shows a horizontal nesting (1) with atomic H-boxes (2) and non-atomic
H-Boxen (3).H boxes (3).
Figur 2 zeigt eine vertikale Verschachtelung (1) mit atomaren V-Boxen (2) und nicht-atomaren V-Figure 2 shows a vertical nesting (1) with atomic V-boxes (2) and non-atomic V-
Boxen (3). Figur 3 zeigt eine Hierarchie von Einheiten (1).Boxing (3). Figure 3 shows a hierarchy of units (1).
Figur 4 zeigt Pfeilverbindungen zwischen H- und V-Boxen. Mit (1) sind L-Pfeile und mit (2) sind R-Figure 4 shows arrow connections between H and V boxes. With (1) are L arrows and with (2) are R-
Pfeile gekennzeichnet. (3) bezeichnet einen Pfeil, der auf einer atomaren H-Box endet.Arrows marked. (3) denotes an arrow that ends on an atomic H-box.
Figur 5 zeigt eine Kreuzungsmarke (1) auf dem Schnittpunkt von einem Pfeil mit einer atomarenFIG. 5 shows an intersection mark (1) on the intersection of an arrow with an atomic one
V-Box. Figur 6 zeigt die Beschriftung von H- und V-Boxen mit Namen (1).V-box. Figure 6 shows the labeling of H and V boxes with names (1).
Figur 7 zeigt die Beschriftung von H- und V-Boxen mit Symbolen (1).Figure 7 shows the labeling of H and V boxes with symbols (1).
5.3 Visuelle Programmelemente5.3 Visual program elements
Im Folgenden wird ausgeführt, wie mithilfe der oben angegebenen graphischen und textuellen Grundelemente Programmbausteine gebildet werden können, aus denen sich auf streng hierarchi- sehe Weise visuelle Computerprogramme zusammensetzen lassen. Figur 8 zeigt ein Programmbeispiel. Unter den Programmbausteinen befinden sich arithmetisch-logische Ausdrücke, Kontrollstrukturen, Objektklassen, sowie höhere funktionale Einheiten. Für die Beschreibung der Semantik dieser Programmbausteine verwenden wir Begriffe der objekt-orientierten Programmiersprache C++. 5.3.1 ObjekteIn the following it is explained how program blocks can be formed from the above-mentioned graphic and textual basic elements, from which visual computer programs can be assembled in a strictly hierarchical manner. Figure 8 shows a sample program. The program modules include arithmetic-logical expressions, control structures, object classes and higher functional units. We use terms from the object-oriented programming language C ++ to describe the semantics of these program modules. 5.3.1 Objects
Wir unterscheiden einfache und zusammengesetzte Objekte. Ein „zusammengesetztes Objekt" wird repräsentiert durch eine V-Box, ein „einfaches Objekt" durch eine atomare V-Box. Wir verwenden zwei Typen von einfachen Objekten, „Skalare" und „Iteratoren", sowie zwei Typen von zusammengesetzten Objekten, „Strukturen" und „Container". Die diesen vier Typen zugeordneten V- Boxen können durch Farbgebung unterschieden werden. Eine weitere Differenzierung der Objekte erfolgt durch Beschriftung ihrer V-Boxen mit Klassen- und Objektnamen, gegebenenfalls gefolgt von weiteren Angaben, wie Dimension, Anfangsbelegung, usw. Figur 9 zeigt ein Beispiel.We differentiate between simple and compound objects. A "composite object" is represented by a V-Box, a "simple object" by an atomic V-Box. We use two types of simple objects, "scalars" and "iterators", and two types of composite objects, "structures" and "containers". The V-boxes assigned to these four types can be distinguished by color. A further differentiation of the objects takes place by labeling their V-boxes with class and object names, possibly followed by further details such as dimension, initial assignment, etc. Figure 9 shows an example.
Ein „Zugriff" auf ein Objekt wird dargestellt durch einen Pfeil. Ein von dem Objekt ausgehender Pfeil symbolisiert einen lesenden Zugriff, der den Objektzustand nicht verändert. Ein auf ihm endender Pfeil stellt einen schreibenden Zugriff dar, der den Objektzustand verändern kann. Le- sende und schreibende Zugriffe werden durch einen Doppelpfeil gekennzeichnet. Auf ein Objekt können mehrere Zugriffe nebeneinander erfolgen, denen dann ebensoviele Pfeile zuzuordnen sind. Die zeitliche Reihenfolge der Zugriffe ist nacheinander von links nach rechts für Pfeile, die auf derselben horizontalen Verschachtelungsebene beginnen oder enden. Zugriffe aus unterschiedlicher Tiefe der horizontalen Verschachtelung heraus erfolgen nacheinander von innen nach außen. Die horizontale Dehnung der V-Boxen visualisiert mit dieser Einschränkung die Zeitachse. Figur 10 zeigt ein Beispiel.An "access" to an object is represented by an arrow. An arrow emanating from the object symbolizes a read access that does not change the state of the object. An arrow ending on it represents a write access that can change the state of the object. Read and write accesses are identified by a double arrow. Multiple accesses to an object can take place side by side, to which as many arrows can then be assigned. The chronological order of accesses is consecutively from left to right for arrows that begin or end on the same horizontal nesting level Different depths of the horizontal nesting take place one after the other from the inside out. The horizontal expansion of the V-boxes visualizes the time axis with this restriction. Figure 10 shows an example.
Die horizontale Ausdehnung der V-Boxen soll auch den Gültigkeitsbereich, sowie die Lebensdauer eines Objektes visualisieren. Der Gültigkeitsbereich eines Objektes erstreckt sich jeweils über die gesamte Breite der horizontalen Verschachtelung einer Einheit. Innerhalb einer Hierarchie von Einheiten lassen sich somit globale Objekte mit abgestuftem Gültigkeitsbereich definieren, jeweils global zu allen Untereinheiten der horizontalen Verschachtelung einer Einheit. Gleichzeitig kennzeichnet das linke Ende einer V-Box die Instanziierung eines Objektes, das rechte Ende sein Verlöschen, jeweils bestimmt durch die Aktivzeit der Einheit. Eine weitere Differenzierung des Gültigkeitsbereiches und der Lebensdauer kann durch entsprechende Wahl einer Speicherklasse erfolgen.The horizontal expansion of the V-Boxes should also visualize the scope of validity and the lifespan of an object. The scope of an object extends across the entire width of the horizontal nesting of a unit. Within a hierarchy of units, global objects with a graduated scope can be defined, globally for all subunits of the horizontal nesting of a unit. At the same time, the left end of a V-Box marks the instantiation of an object, the right end its extinction, determined by the active time of the unit. A further differentiation of the area of validity and the service life can be made by selecting a storage class accordingly.
SkalareScalars
Skalare sind Objekte, deren innere Struktur nicht sichtbar ist. Der Zugriff auf die innere Struktur erfolgt ausschließlich über Elementfunktionen oder -Operatoren. Es können eingebaute Skalare zur Verfügung gestellt werden, z.B. Integer oder Character. Daraus, sowie mithilfe von Strukturen, Containern und Iteratoren lassen sich neue Objekte bilden, die wiederum als Skalar definierbar sind. Figur 11 zeigt ein Beispiel.Scalars are objects whose inner structure is not visible. The inner structure is only accessed via element functions or operators. Built-in scalars can be made available, e.g. Integer or character. From this, as well as with the help of structures, containers and iterators, new objects can be formed, which in turn can be defined as scalar. Figure 11 shows an example.
Strukturen Strukturen sind Objekte, deren innere Struktur offengelegt ist. Sie enthalten in fester Anordnung eine feste Anzahl von Objekten beliebigen Typs. Eine Struktur kann ohne Einschränkung in vertikaler Verschachtelung Skalare, Iteratoren, Container und wieder Strukturen enthalten. Zugriffe auf die Elemente einer Struktur können auch ohne Elementfunktionen oder -Operatoren erfolgen, indem Pfeile direkt auf die Strukturelemente geführt werden. Figur 12 zeigt ein Beispiel.Structures Structures are objects whose inner structure is exposed. They contain a fixed number of objects of any type in a fixed arrangement. A structure can contain scalars, iterators, containers and again structures in vertical nesting without restriction. The elements of a structure can also be accessed without element functions or operators by directing arrows on the structure elements. Figure 12 shows an example.
Container und IteratorenContainers and iterators
Container sind Objekte, die in der Regel eine unbestimmte Anzahl von Objekten homogenen Typs enthalten, welche in einer regulären Struktur (z.B. Feld, Kette, Baum) zusammengefaßt sind. Container sind unabhängig vom Datentyp ihrer Elemente definiert. Der Datentyp ihrer Elemente wird festgelegt, indem in sie genau ein Objekt bestimmten Typs eingesetzt wird. Das eingesetzte Objekt repräsentiert damit alle Containerelemente. Der Zugriff auf ein Element des Containers wird durch einen Pfeil bezeichnet, der auf dem repräsentativen Element endet oder von ihm ausgeht.Containers are objects that usually contain an indefinite number of objects of homogeneous type, which are combined in a regular structure (e.g. field, chain, tree). Containers are defined regardless of the data type of their elements. The data type of their elements is determined by inserting exactly one object of a certain type into them. The object used thus represents all container elements. Access to an element of the container is indicated by an arrow that ends or starts on the representative element.
Zugriffe auf Containerelemente erfolgen in der Regel innerhalb einer Traverse, welche die reguläre Struktur des Containers nach einem Schema durchläuft und die Elementpositionen ermittelt. Durchlaufschema und aktuell erreichte Position innerhalb eines Containers sind hier vom eigentlichen Container getrennt und zu einem Iterator-Objekt zusammengefaßt. Auch der Iterator ist unabhängig vom Datentyp der Containerelemente. Jedoch ist der Typ des traversierten Containers Bestandteil des Iteratortyps. Der Klassenname eines Iterators bezeichnet den Algorithmus einer Traverse auf einem Container bestimmten Typs (nicht ElementtypsJ. Durch Zugriffe auf den Iterator mittels seiner Elementfunktionen und -Operatoren kann die in ihm verwaltete Position eines Containerelements entsprechend dem Traversieralgorithmus verändert werden.Access to container elements usually takes place within a traverse, which runs through the regular structure of the container according to a schema and determines the element positions. The flow scheme and the position currently reached within a container are separated from the actual container and combined to form an iterator object. The iterator is also independent of the data type of the container elements. However, the type of traversed container is part of the iterator type. The class name of an iterator designates the algorithm of a traverse on a container of a certain type (not element type J). By accessing the iterator using its element functions and operators, the position of a container element managed in it can be changed according to the traversing algorithm.
Im Allgemeinen können auf einem Container mehrere verschiedene Traversen, sowie auch auf mehreren Containern verschiedene Traversen gleichzeitig aktiv sein. Die Auswahl und Zuordnung einer Traverse zu einem Container geschieht für jeden Zugriff separat, indem der Schnittpunkt von Zugriffspfeil und Iterator mit einer Kreuzungsmarke belegt wird. Die Kreuzungsmarke besitzt die Funktion eines Dereferenz- oder Inhaltsoperators. Eine Zuordnung ist nur möglich für Iteratoren, die oberhalb des Containers liegen. Die Zuordnung wird dokumentiert durch Beschriftung des Containers mit dem Objektnamen des Iterators auf der Höhe des Zugriffspfeils.In general, several different trusses can be active on one container, as well as different trusses on several containers at the same time. The selection and assignment of a traverse to a container is done separately for each access by placing an intersection mark on the intersection of the access arrow and the iterator. The cross mark has the function of a dereference or content operator. An assignment is only possible for iterators that are above the container. The assignment is documented by labeling the container with the object name of the iterator at the level of the access arrow.
Ohne Iterator erfolgt der Zugriff auf einen Container als Ganzes. In diesem Fall endet der Zugriffs- pfeil auf dem Container. Ohne Iterator erfolgt auch der Elementzugriff für Container wie z.B Stack und Queue. In ihrem Fall erfolgt der Zugriff über Elementfunktionen oder -Operatoren, wobei der Zugriffspfeil ebenfalls auf dem Container endet. Figur 13 zeigt ein Beispiel.A container as a whole is accessed without an iterator. In this case, the access arrow ends on the container. Without an iterator, elements such as stack and queue can also be accessed. In their case, access is via element functions or operators, with the access arrow also ending on the container. Figure 13 shows an example.
Durch Verschachtelung von Containern können mehrdimensionale Container erzeugt werden. Entsprechend sind beim Zugriff auf die Elementardaten mehrere Iteratoren nötig. Jedem Container einer Verschachtelung, der vom Zugriffspfeil durchdrungen wird, ist ein Iterator zuzuordnen und dieser mit einer Kreuzungsmarke zu belegen. Die einer Verschachtelung von Containern zugeordneten Iteratoren können als Koordinaten der Container-Elemente betrachtet werden. Figur 14 zeigt ein Beispiel.By nesting containers, multidimensional containers can be created. Accordingly, several iterators are required when accessing the elementary data. An iterator must be assigned to each container in a nesting that is penetrated by the access arrow and to mark this with a crossing mark. The iterators assigned to a nesting of containers can be viewed as coordinates of the container elements. Figure 14 shows an example.
Ein Iterator kann selbst wieder Element eines Containers sein und benötigt seinerseits einen Iterator für die Traverse und den Zugriff. Auf diese Weise kann ein Containerelement indirekt adressiert werden. Die Zuordnungen von Iteratoren zu Containern, die selbst wieder zugeordnete Iteratoren enthalten, werden wie oben als Kreuzungspunkte auf dem Zugriffspfeil markiert. Dadurch, daß ein Iterator stets oberhalb des ihm zugeordneten Containers liegt, ist die Gesamtzu- Ordnung zyklenfrei. Pro Zugriff ist die Zuordnung zwischen Iteratoren und Containern außerdem bijektiv. Figur 15 zeigt ein Beispiel.An iterator can itself be an element of a container and in turn requires an iterator for the traverse and access. In this way, a container element can be addressed indirectly. The assignments of iterators to containers that themselves contain reassigned iterators are marked as crossing points on the access arrow as above. Because an iterator is always above the container assigned to it, the overall assignment is cycle-free. The assignment between iterators and containers is also bijective per access. Figure 15 shows an example.
5.3.2 Speicherklassen5.3.2 Storage classes
Wir unterscheiden Speicherklassen, um für Objekte den Gültigkeitsbereich und die Lebensdauer genauer spezifizieren zu können. Dazu werden die Speicherklassen „STATIC", „DYNAMIC" und „DISTRIBUTED" eingeführt und als Struktur bzw. als Container repräsentiert, mit entsprechender Beschriftung ihrer V-Boxen. Dabei gelten folgende syntaktische Einschränkungen: (1) STATIC-, DYNAMIC- und DISTRIBUTED-Größen können nur auf oberster Ebene einer vertikalen Ver- schachtelung deklariert werden, insbesondere dürfen sie nicht ineinander eingesetzt werden. (2) STATIC-, DYNAMIC-, sowie DISTRIBUTED-Deklarationen können jeweils nicht mehr als ein Objekt aufnehmen.We differentiate between storage classes so that the scope and lifespan of objects can be specified more precisely. For this purpose, the storage classes "STATIC", "DYNAMIC" and "DISTRIBUTED" are introduced and represented as a structure or as a container, with the appropriate labeling of their V-boxes. The following syntactical restrictions apply: (1) STATIC, DYNAMIC and DISTRIBUTED Sizes can only be declared at the top level of a vertical nesting, in particular they must not be used in one another. (2) STATIC, DYNAMIC, and DISTRIBUTED declarations cannot contain more than one object at a time.
Als STATIC vereinbarte Objekte besitzen einen lokalen Gültigkeitsbereich bezogen auf eine Funk- tionale Einheit, aber eine - innerhalb der Prozeß laufzeit - unbegrenzte Lebensdauer. Sie eignen sich u.a. für die Initialisierung lokaler Größen. Die Lebensdauer von DYNAMIC-Objekten kann dagegen beliebig gestaltet werden, was z.B. für die Konstruktion von Containern genutzt werden kann. Der Gültigkeitsbereich von DYNAMIC-Objekten ist grundsätzlich global. Sie sind für den Zugriff ohne Einschränkung verfügbar, wenn ihre Position bekannt ist.Objects agreed as STATIC have a local area of validity related to a functional unit, but an unlimited lifespan - within the process runtime. Among other things, they are suitable for the initialization of local quantities. The lifespan of DYNAMIC objects, on the other hand, can be designed as desired, which e.g. can be used for the construction of containers. The scope of DYNAMIC objects is generally global. They are available for access without restriction if their position is known.
Der Zugriff auf STATIC-Größen erfolgt gemäß den Regeln für Strukturen, während auf DYNAMIC- Größen - wie auf Containerelemente - über Iteratoren zugegriffen wird. Für die Speicherklasse DYNAMIC gibt es zwei eingebaute Elementfunktionen, 'create' und 'delete'. 'Create' erzeugt ein Objekt vom Typ des in den DYNAMIC-Container eingesetzten repräsentativen Objekts und liefert als Returnwert die Position des erzeugten Objekts, die in der Regel einem Iterator zugewiesen wird. Über diesen Iterator kann das Element auch wieder gelöscht werden, wobei der Iterator als Argument von 'delete' auftritt. Der Iterator für DYNAMIC ist "eingebaut". Er enthält keine Traversenfunktion. Dafür verwaltet er aber neben der Position (im Heap) auch die Typangabe des DY- NAMIC-Elementes. Diese wird für Konsistenzprüfungen herangezogen. DISTRIBUTED-Objekte besitzen eine von der Systemlaufzeit unabhängige, unbegrenzte Lebensdauer. Sie werden keinem Prozeß des Systems eindeutig zugeordnet, sind migrationsfähig und können prinzipiell in einem externen System implementiert sein. Ihr Gültigkeitsbereich ist platt- form-übergreifend global. Der Zugriff erfolgt über Elementfunktionen. Figur 16 zeigt ein Beispiel.STATIC variables are accessed according to the rules for structures, while DYNAMIC variables - like container elements - are accessed via iterators. There are two built-in element functions for the DYNAMIC storage class, 'create' and 'delete'. 'Create' creates an object of the type of the representative object used in the DYNAMIC container and returns the position of the created object as a return value, which is usually assigned to an iterator. The element can also be deleted using this iterator, the iterator appearing as an argument to 'delete'. The iterator for DYNAMIC is "built in". It contains no truss function. In addition to the position (in the heap), it also manages the type specification of the DYNAMIC element. This is used for consistency checks. DISTRIBUTED objects have an unlimited lifespan that is independent of the system runtime. They are not clearly assigned to any process in the system, are capable of migration and can in principle be implemented in an external system. Their scope is global across all platforms. Access is via element functions. Figure 16 shows an example.
5.3.3 Ausdrücke5.3.3 Expressions
Wir unterscheiden einfache und zusammengesetzte Ausdrücke. Ein „zusammengesetzter Ausdruck" wird repräsentiert durch eine H-Box, ein „einfacher Ausdruck" durch eine atomare H-Box. Wir verwenden zwei Typen von zusammengesetzten Ausdrücken, „Funktionen" und „Operationen" (genauer gesagt, die Aufrufe derselben), sowie einfache Ausdrücke als „Argumente" von Funktionen und Operationen. Die diesen Ausdruckstypen zugeordneten H-Boxen können durch Farbgebung unterschieden werden. Eine weitere Differenzierung der Funktionen und Operationen erfolgt durch Beschriftung ihrer H-Boxen mit Funktionsnamen bzw. Operatorsymbolen. Argumente werden weiter unterschieden in Eingabe-, Ausgabe- und Ein-Ausgabe-Argumente. Argumente können mit einem Pfeil versehen sein und repräsentieren damit das Objekt, auf dem der Pfeil endet, als Parameter der Funktion bzw. Operation. Entsprechend ihrer Unterscheidung in Eingabe-, Ausgabe- und Ein-Ausgabe-Argumente werden sie über eingehende, ausgehende oder ein-und-ausgehende Pfeile mit den Objekten verbunden. Eingabe-Argumente können auch ohne Reil spezifiziert werden, indem sie (ggf. in abgekürzter Schreibweise) direkt mit dem Wert oder dem Namen einer Konstanten beschriftet werden. Die Identifizierung eines Argumentes geschieht über seine Position innerhalb der Argumentfolge einer Funktion oder Operation. Figur 17 zeigt ein Beispiel.We differentiate between simple and compound expressions. A "compound expression" is represented by an H-box, a "simple expression" by an atomic H-box. We use two types of compound expressions, "functions" and "operations" (more precisely, the calls to them), as well as simple expressions as "arguments" of functions and operations. The H-boxes assigned to these expression types can be distinguished by color Further differentiation of the functions and operations takes place by labeling their H-boxes with function names or operator symbols. Arguments are further differentiated into input, output and input-output arguments. Arguments can be marked with an arrow and thus represent the object which the arrow ends as a parameter of the function or operation. According to their differentiation in input, output and input-output arguments, they are connected to the objects by means of incoming, outgoing or incoming and outgoing arrows. Input arguments can can also be specified without a reil by directly (if necessary in abbreviated form) with the value o which are labeled with the name of a constant. An argument is identified by its position within the argument sequence of a function or operation. Figure 17 shows an example.
Auch ein zusammengesetzter Ausdruck kann Eingabe-Argument einer Funktion oder Operation sein. Das Ergebnis einer Funktion oder Operation wird jeweils durch die H-Box ihres Aufrufs repräsentiert und kann durch direktes Einsetzen an der Position eines Funktions- oder Operationsargumentes verwendet werden. Der Datentyp des Ergebnisses muß dabei mit dem Datentyp des Funktions- oder Operationsargumentes übereinstimmen. Funktionen und Operationen können fortlaufend ineinander eingesetzt werden und bilden im allgemeinen Fall eine horizontale Verschachtelung. Das Ergebnis einer Funktion oder Operation kann auch durch „Zuweisung" verwendet werden. Dazu wird ein R-Pfeil auf das Objekt geführt, dem das Ergebnis zugewiesen werden soll.A compound expression can also be an input argument to a function or operation. The result of a function or operation is represented by the H box of its call and can be used by inserting it directly at the position of a function or operation argument. The data type of the result must match the data type of the function or operation argument. Functions and operations can be used continuously in one another and generally form a horizontal nesting. The result of a function or operation can also be used by "assignment". To do this, an R arrow is directed to the object to which the result is to be assigned.
Die „Elementbeziehung" einer Funktion oder Operation zu einem Objekt wird durch einen L-Pfeil zwischen dieser Funktion oder Operation und dem Objekt dargestellt. Durch die Pfeilrichtung kann näher bezeichnet werden, ob das Objekt verändert oder nur gelesen wird oder beides. Im Fall einer weder lesenden noch schreibenden Beziehung degeneriert der L-Pfeil zu einer ungerichteten Verbindungslinie. Die zeitliche Reihenfolge der Objekt-Zugriffe ist nacheinander von links nach rechts für Pfeile, die auf derselben horizontalen Verschachtelungsebene beginnen oder enden. Dies gilt auch für die L- und R-Pfeile derselben H-Box. Zugriffe aus unterschiedlicher Tiefe der horizontalen Verschachtelung heraus erfolgen nacheinander von innen nach außen. Figur 18 zeigt ein Beispiel.The "element relationship" of a function or operation to an object is represented by an L-arrow between this function or operation and the object. The direction of the arrow can be used to specify whether the object is changed or only read or both. In the case of neither The reading and writing relationship degenerates into an undirected connecting line. The chronological order of the object accesses is consecutively from left to right for arrows that begin or end on the same horizontal nesting level. This also applies to the L and R arrows of the same H box. Access from different depths of the horizontal nesting takes place one after the other from the inside out. Figure 18 shows an example.
5.3.4 Kontrollstrukturen5.3.4 Control structures
Eine Kontrollstruktur wird repräsentiert durch eine (farblich hervorgehobene) Einheit, welche in ihrer horizontalen Verschachtelung von links nach rechts folgende H-Boxen enthält: Zunächst einen „Prolog", welcher beliebig viele Ausdrücke (oder auch höhere Funktionale Einheiten) enthalten kann, z.B. für eine Initialisierung. Die letzte (farblich hervorgehobene) Einheit dieses Prologs muß ein Ausdruck sein. Er stellt die „Pre-Condition" dar. Darauf folgen ein oder mehrere „Cases". Ein Case wird jeweils repräsentiert durch eine Einheit, welche mit einer „Post-Condition" beschriftet ist. Diese enthält einen Vergleichsoperator, gefolgt von einer Konstanten (Wert oder Name; DEFAULT ist der Name einer eingebauten Post-Condition, die dem eise- oder default-Fall entspricht und immer erfüllt wird). Ein Case ist erfüllt, wenn die Berechnung der Konkatenation von Pre-Condition und Post-Condition den Wahrheitswert 1 ergibt. Die Auswertung der Wahrheitswerte geschieht in der Reihenfolge der Anordnung der Cases. Der erste erfüllte Case innerhalb der Kontrollstruktur wird ausgeführt.A control structure is represented by a (highlighted) unit, which contains the following H boxes in its horizontal nesting from left to right: First a "prologue", which can contain any number of expressions (or even higher functional units), e.g. for one Initialization. The last (highlighted) unit of this prologue must be a printout. It represents the "pre-condition". This is followed by one or more "cases". A case is each represented by a unit that is marked with a "post Condition "is labeled. This contains a comparison operator followed by a constant (value or name; DEFAULT is the name of a built-in post condition that corresponds to the ice or default case and is always fulfilled). A case is fulfilled if the calculation of the concatenation of pre-condition and post-condition gives the truth value 1. The truth values are evaluated in the order in which the cases are arranged. The first fulfilled case within the control structure is executed.
Wir unterscheiden zwei Case-Typen, „SELECT" und „REPEAT". Beide Typen können gemischt innerhalb einer Kontrollstruktur auftreten. Nach Ausführung einer SELECT-Einheit wird die Kontrollstruktur verlassen. Nach Ausführung einer REPEAT-Einheit erfolgt erneut die Bestimmung der Wahrheitswerte aus der Pre-Condition und den Post-Conditions der Cases mit anschließender Ausführung eines Case. Die Figuren 19 bis 25 zeigen Beispiele.We differentiate between two case types, "SELECT" and "REPEAT". Both types can occur mixed within a control structure. The control structure is exited after execution of a SELECT unit. After executing a REPEAT unit, the truth values are determined again from the pre-condition and post-conditions of the cases, followed by the execution of a case. Figures 19 to 25 show examples.
Weitere sinnvolle Kontrollstrukturen können „Exceptions" und „Threads" sein, mit denen sich Ausnahmebehandlung und Parallelität ausdrücken lassen. Jeder sequentiell auszuführenden Folge von Operationen kann eine Menge von sequentiell auszuführenden Operationenfolgen zugeordnet werden, welche die Ausnahmebehandlung vornehmen. Ebenso können mehrere sequentiell auszuführende Operationenfolgen zu einem Block zusammengefaßt werden, der simultan ausgeführt wird. Für diese beiden Strukturen kann eine verdeckte Anordnung von Vorteil sein, die erst im Bedarfsfall (Editieren, Animation, Views, Navigieren) sichtbar wird.Other useful control structures can be "exceptions" and "threads", which can be used to express exception handling and parallelism. Each sequence of operations to be carried out sequentially can be assigned a set of sequence of operations to be carried out sequentially, which carry out the exception handling. Likewise, several sequences of operations to be carried out sequentially can be combined to form a block which is carried out simultaneously. A hidden arrangement can be advantageous for these two structures, which becomes visible only when necessary (editing, animation, views, navigation).
Die als Funktion dargestellten (farblich hervorgehobenen) „Terminatoren" 'throw', 'break' und 'continue' können in der von C++ her bekannten Bedeutung verwendet werden. Mit ihnen kann eine Kontrollstruktur verlassen oder modifiziert werden.The "Terminators" 'throw', 'break' and 'continue' shown as a function (highlighted in color) can be used in the way known from C ++. They can be used to leave or modify a control structure.
5.3.5 Funktionale Einheiten Je eine horizontale und vertikale Verschachtelung werden zusammengefaßt zu einer Funktionalen Einheit. Figur 26 zeigt ein Beispiel. Die kleinsten Funktionalen Einheiten, -mit leerer vertikaler Verschachtelung, sind die „Ausdrücke". Höhere Funktionale Einheiten ergeben sich durch horizontale Verschachtelung niederer funktionaler Einheiten und Ergänzung mit einer vertikalen Verschachtelung zu einer neuen funktionalen Einheit. Auf diese Weise lassen sich „Blöcke" unterschiedlicher Hierarchiestufe bilden, „Definitionen von Funktionen und Operationen", „Definitionen von Klassen und Unterklassen", „Funktionsbibliotheken", „Module" unterschiedlicher Hierarchiestufe, „Systemkomponenten", „Systemebenen" und „Systeme".5.3.5 Functional units Horizontal and vertical nesting are combined to form a functional unit. Figure 26 shows an example. The smallest functional units, with empty vertical nesting, are the "expressions". Higher functional units result from horizontal nesting of lower functional units and supplementation with a vertical nesting to a new functional unit. In this way, "blocks" of different hierarchical levels can be created form, "definitions of functions and operations", "definitions of classes and subclasses", "function libraries", "modules" of different hierarchical levels, "system components", "system levels" and "systems".
Die in der horizontalen Verschachtelung einer Funktionalen Einheit enthaltenen Funktionalen SubEinheiten kommunizieren über die Objekte der vertikalen Verschachtelung dieser Einheit (oder jeder übergeordneten Einheit). Im Falle einer Funktionsdefinition sind es die lokalen Objekte, über welche die Ausdrücke kommunizieren. Figur 27 zeigt ein Beispiel. Im Falle einer Klassendefinition sind es die Datenelemente, über welche die Elementfunktionen kommunizieren und die zu den Elementfunktionen global liegen. Im Falle einer Funktionsbibliothek sind es die globalen Objekte. Im Falle der obersten Systemebene sind es die Nachrichten-, Sychronisations- oder Verteilten Objekte, über welche die Prozesse miteinander kommunizieren. Der Zugriff auf diese Objekte erfolgt immer durch Kleinste Funktionale Einheiten, die über vertikalen Pfeilzugriff sämtliche Objekte aller übergeordneten Einheiten erreichen können, da diese, von innen nach außen, je- weils in zunehmender Breite untereinanderliegen. Figur 28 zeigt ein Beispiel.The functional subunits contained in the horizontal nesting of a functional unit communicate via the objects of the vertical nesting of this unit (or each higher-level unit). In the case of a function definition, it is the local objects through which the expressions communicate. Figure 27 shows an example. In the case of a class definition, it is the data elements via which the element functions communicate and which are global to the element functions. In the case of a function library, it is the global objects. In the case of the highest system level, it is the message, synchronization or distributed objects through which the processes communicate with each other. These objects are always accessed by the smallest functional units, which can access all objects of all higher-level units via vertical arrow access, since these are located inside each other in increasing width, from the inside out. Figure 28 shows an example.
Die als Funktion dargestellten (farblich hervorgehobenen) „Terminatoren" 'return', 'exit', 'abort', 'terminate' können in der von C++ her bekannten Bedeutung verwendet werden. Mit ihnen kann eine Funktionale Einheit verlassen werden.The "Terminators" 'return', 'exit', 'abort', 'terminate' shown as a function (highlighted in color) can be used in the way they are known from C ++. They can be used to leave a functional unit.
5.3.6 Selbsterweiterbarkeit5.3.6 Self-expandability
Mit den obengenannten Graphikelementen wurde bisher der Aufruf einer Funktion oder Operation, sowie die Instanziierung eines Objekts beschrieben. Mit denselben graphischen Mitteln können auch die „Definitionen" dieser Funktionalen Einheiten beschrieben werden. Dazu führen wir folgende eigenständigen Typen Funktionaler Einheiten (mit entsprechender farblicher Kennzeichnung) ein: die „Funktion", die „Operation", die „Klasse", die „Funktionsbibliothek", sowie nach Bedarf weitere, bis zur Hierarchiestufe des „Systems".Up to now, the call of a function or operation and the instantiation of an object have been described with the above-mentioned graphic elements. The "definitions" of these functional units can also be described using the same graphic means. For this purpose, we introduce the following independent types of functional units (with appropriate color coding): the "function", the "operation", the "class", the "function library" ", as well as other, if necessary, up to the hierarchical level of the" system ".
Die Einheiten der Funktion und der Operation werden mit dem „Funktionsnamen" bzw. dem „Operatorsymbol" beschriftet. Er entspricht dem Aufrufnamen bzw. -symbol. Unter den Objekten ihrer vertikalen Verschachtelung werden die „Aufruf-Parameter" mit einem Pfeilsymbol als IN-, OUT- oder IN-OUT-Parameter gekennzeichnet. Figur 8A zeigt ein Beispiel. Der Reihenfolge ihres Auftretens von oben nach unten entspricht die Aufrufreihenfolge von links nach rechts. Der „Returnwert" der Funktion oder Operation wird als Argument eines farblich besonders gekennzeichneten Terminators übergeben. Es kann mehrere solcher Terminatoraufrufe geben, deren Argumente auf Konsistenz überprüft werden. Die Spezifikation als Argument ist gleichzeitig die Typ-Deklaration des Returnwertes.The units of the function and the operation are labeled with the "function name" or the "operator symbol". It corresponds to the call name or symbol. Under the objects of their vertical nesting, the "call parameters" are identified with an arrow symbol as IN, OUT or IN-OUT parameters. FIG. 8A shows an example. The order of their occurrence from top to bottom corresponds to the order of calling from left to right right. The "return value" of the function or operation is passed as an argument of a color-coded terminator. There may be several such terminator calls, their Arguments are checked for consistency. The specification as an argument is also the type declaration of the return value.
Eine Klasse wird allgemein als Funktionale Einheit definiert, welche in ihrer horizontalen Verschachtelung die Einheiten der „Elementfunktionen" enthält, sowie in ihrer vertikalen Verschachtelung die „Datenelemente" (global zu den Elementfunktionen). Sie wird mit dem „Klassennamen" beschriftet, der bei der Instanziierung eines Objekts dieser Klasse verwendet wird. Es folgen in <>-Klammern die „Konfigurations-Parameter" der Klasse, wie z.B. eine Anfangsbelegung, Größe, usw., die den Konstruktor-Parametern entsprechen. Figur 29 zeigt ein Beispiel.A class is generally defined as a functional unit, which contains the units of the "element functions" in its horizontal nesting, and the "data elements" in its vertical nesting (global to the element functions). It is labeled with the "class name" that is used when an object of this class is instantiated. The "configuration parameters" of the class follow in <> - brackets, e.g. an initial assignment, size, etc. that correspond to the constructor parameters. Figure 29 shows an example.
Gemäß den angegebenen Klassentypen wird die Funktionale Einheit der Klasse weiter differenziert in SCALAR, CONTAINER und ITERATOR, sowie STRUCTURE. Für Sealare sind keine weiteren Merkmale vorgesehen. Die Datenelemente eines Sealars sowie eines Iterators sind nur über Elementfunktionen zugreifbar und sind somit privaten Typs.According to the specified class types, the functional unit of the class is further differentiated into SCALAR, CONTAINER and ITERATOR, as well as STRUCTURE. No other features are provided for Sealare. The data elements of a sealar and an iterator are only accessible via element functions and are therefore of a private type.
Zwischen Container und Iterator muß zunächst eine formale Zuordnung getroffen werden, die es einem Iterator erlaubt, direkt auf die Datenelemente eines Containers zuzugreifen. Die Zuordnung erfolgt durch Eintrag des Iterator-Klassennamens in eine dem Container assoziierte Liste. Ebenso wird dem Iterator der Container-Klassenname zugeordnet. Die Implementierung des eigentlichen Containers geschieht in der Regel mithilfe der DYNAMIC-Speicherklasse. Die Containerelemente sind dabei als STRUCTURE-Objekte definiert und enthalten Iterator-Objekte für ihre Verkettung.A formal assignment must first be made between the container and the iterator, which allows an iterator to directly access the data elements of a container. The assignment is made by entering the iterator class name in a list associated with the container. The container class name is also assigned to the iterator. The actual container is usually implemented using the DYNAMIC storage class. The container elements are defined as STRUCTURE objects and contain iterator objects for their concatenation.
Structure-Klassen sind öffentlichen Typs und erlauben den direkten Zugriff auf ihre Elemente über Zugriffspfeile. Ähnlich wie verschachtelte Container werden sie direkt über Editierfunktionen er- zeugt und können zur Festlegung ihres Gültigkeitsbereiches einer höheren Funktionalen Einheit zugeordnet werden.Structure classes are public types and allow direct access to their elements via access arrows. Similar to nested containers, they are created directly via editing functions and can be assigned to a higher functional unit to determine their scope.
„Freie Funktionen", die nicht Element einer Klasse sind, können in „Funktionsbibliotheken" (Interfaces) zusammengefaßt werden. Auch sie werden als Funktionale Einheit definiert und enthalten in ihrer vertikalen Verschachtelung globale Objekte, über welche die Funktionen kommunizieren."Free functions" that are not part of a class can be summarized in "function libraries" (interfaces). They too are defined as a functional unit and, in their vertical nesting, contain global objects via which the functions communicate.
5.J.7 Vererbung5.J.7 Inheritance
Eine Klasse, die in die horizontale Verschachtelung einer anderen Klasse eingesetzt wird, erbt da- mit alle Funktionen, Operatoren und Datenelemente der umschließenden Klasse. Die Definition einer Sub-Klasse erfolgt auf derselben Ebene wie die Definition der Funktionen und Operatoren der umschließenden Klasse. Innerhalb der Sub-Klasse können Funktionen und Operatoren der Oberklassen neu-definiert und als „virtuell" oder „static" gekennzeichnet werden. Der Zugriff von Sub-Klassen auf die Datenelemente von Oberklassen kann optional eingeschränkt werden. De- fault-mäßig entsprechen diese Datenelemente globalen (protected) Größen. Das Schema der ho- πzontalen Verschachtelung laßt beliebige einfache Vererbungsbeziehungen zu Figur 32 zeigt ein BeispielA class that is used in the horizontal nesting of another class thus inherits all functions, operators and data elements of the enclosing class. A subclass is defined at the same level as the functions and operators of the enclosing class. Within the sub-class, functions and operators of the upper classes can be redefined and identified as "virtual" or "static". The access of subclasses to the data elements of superclasses can optionally be restricted. By default, these data elements correspond to global (protected) sizes. The scheme of the high πzonal nesting lets any simple inheritance relationship to Figure 32 shows an example
53 8 Abstraktion und Verzroberung53 8 Abstraction and chorus
Abstraktion und Vergröberung einer funktionalen Einheit ergeben sich durch Verdecken von Details innerhalb der ihr zugeordneten H-Box Blockdiagramme erhalt man beispielsweise durch Weglassen sämtlicher Details bis auf die Beziehungspfeile zu globalen Objekten und die Namensbeschriftung Die Beziehungspfeile enden in diesem Fall an der Unterkante der funktionalen Em- heit Gleichartige Beziehungspfeile lassen sich weiter zu einem repräsentativen Pfeil zusammenfassen Figur 30 zeigt ein Beispiel Schnittsteilen-Diagramme erhalt man durch Weglassen sämtlicher Details einer Funktion oder Operation bis auf die als Parameter gekennzeichneten Objekte und die Namensbeschrrftuπg. Die Parameter-Objekte können horizontal verkürzt und mit ihrer Beschriftung angezeigt werdenAbstraction and coarsening of a functional unit result from hiding details within the H-Box block diagrams assigned to it, for example, by omitting all details except for the relationship arrows to global objects and the name inscription. The relationship arrows in this case end at the lower edge of the functional em- Similar relationship arrows can be further combined to form a representative arrow. FIG. 30 shows an example of sectional diagrams obtained by omitting all details of a function or operation except for the objects identified as parameters and the name description. The parameter objects can be shortened horizontally and displayed with their labels
Für eine Vergroberung lassen sich Details wahrend des Editiervorgangs willkürlich als relevant bzw nicht-relevant kennzeichnen Bei einer vergröberten Anzeige werden die als nicht-relevant eingestuften Details verdeckt Figur 31 zeigt ein BeispielFor a coarsening, details can be arbitrarily marked as relevant or not relevant during the editing process. In the case of a coarsened display, the details classified as not relevant are hidden. FIG. 31 shows an example
53 9 Programm-Beispiele53 9 Program examples
Figur 8A zeigt den bekannten rekursiveπ Algorithmus Quicksort in einer vollständigen Visualisierung nach dem hier beschriebenen Verfahren Der Datenteil enthalt fünf Objekte, darunter vier Iteratoren, wovon zwei als Eingabeparameter markiert sind Das zu sortierende Feld von Objekten des Typs 'int' ist als Ein- und Ausgabeparameter gekennzeichnet Auf die Iteratoren erfolgen schreibende und lesende Zugriffe Das Feld 'a' als Ganzes wird fünfmal als Funktionsargument übergeben Zwei lesende Zugriffe auf Feldelemente erfolgen über die Iteratoren ϊ und 'links' Hier wird der Vergleich a[ij<a[lιnks] durchgeführt Der Operationsteil enthalt fünf Funktionsaufrufe, davon zwei rekursive Aufrufe von Quicksort Die Funktionsargumente bestehen zum Teil aus komplexen Ausdrucken Im mittleren Bereich des Operationsteils befinden sich zwei ineinander verschachtelte Kontrollstrukturen, die äußere repetitiv, mit einem Prolog, der aus einer Addition besteht Die innere Kontrollstruktur ist selektiv und führt bei Erfüllen der Vergleichsbedingung zu einem Aufruf der Funktion 'tausch' Figur 8B soll, beispielhaft und unabhängig von einer geometrischen Ausfuhrung, das allgemeine topologische Prinzip des erfindungsgemaßen Verfahrens verdeutlichen, nach dem ein Algorithmus visualisiert wird. Es sind erkennbar die Baumstruktur (1) der Operationen, die Baumstruktur (2) der Operanden, die Hilfslinien (3) zur Dehnung der Operanden längs der Zeitachse, sowie die Linien (4) zur Darstellung von Argument- Zuweisungs- und Element-Beziehungen mit ihren Auftreffpunkten (5) und Kreuzungsmarken (6)FIG. 8A shows the known recursive algorithm Quicksort in a complete visualization according to the method described here. The data part contains five objects, including four iterators, two of which are marked as input parameters. The field of objects of the type 'int' to be sorted is an input and output parameter marked Write and read accesses to the iterators The field 'a' as a whole is passed five times as a function argument. Two read accesses to field elements are carried out via the iterators ϊ and 'left'. Here the comparison a [ij <a [lιnks] is carried out. The operation part contains five function calls, two of which are recursive calls to Quicksort. The function arguments partly consist of complex printouts. In the middle area of the operation part there are two interleaved control structures, the outer repetitive, with a prologue consisting of an addition. The inner control structure is selective and If the comparison condition is met, the function "exchange" is called. FIG. 8B is intended to illustrate, by way of example and independently of a geometric design, the general topological principle of the method according to the invention, according to which an algorithm is visualized. The tree structure (1) of the operations, the tree structure (2) of the operands, the auxiliary lines (3) for expanding the operands along the time axis, and the lines (4) for representing argument-assignment and element relationships can be seen their points of impact (5) and crossing marks (6)
BERICHTIGTES BLATT (REGEL 91) ISA/EP Figur 9 zeigt die hier verwendeten vier Grundmuster von Objekten, SKALAR, ITERATOR, CONTAINER und STRUKTUR Durch Beschriftung mit Klassen- und Objektnamen, teilweise mit Anfangswert, ergeben sich vollständig spezifizierte Objektdeklarationen Figur 10 zeigt die Zugrrffsmoglichkeiten für ein verschachteltes Objekt Die Zugriffe können in je- der Tiefe erfolgenCORRECTED SHEET (RULE 91) ISA / EP FIG. 9 shows the four basic patterns of objects used here, SCALAR, ITERATOR, CONTAINER and STRUCTURE. Labeling with class and object names, sometimes with an initial value, results in completely specified object declarations. FIG. 10 shows the access options for a nested object. the depth
Figur 11 zeigt einen schreibenden und lesenden Zugriff auf einen SKALAR oder ITERATORFIG. 11 shows a write and read access to a SCALAR or ITERATOR
Figur 12 zeigt schreibende und lesende Zugriffe auf eine STRUKTUR als Ganzes und auf ihreFIG. 12 shows write and read accesses to a STRUCTURE as a whole and to it
Elementeelements
Figur 13 zeigt lesende und schreibende Zugriffe auf einen Container als Ganzes, sowie lesende und schreibende Zugriffe auf Containerelemente über einen Iterator der Klasse 'inorder' Der Iterator kann selbst gelesen und verändert werdenFIG. 13 shows read and write accesses to a container as a whole, as well as read and write accesses to container elements via an iterator of the 'inorder' class. The iterator can be read and changed by the user
Figur 14 zeigt lesende und schreibende Zugriffe auf verschachtelte Container. Der Zugriff auf den Baum der Klasse 'bäum' erfolgt als Ganzes und somit ohne Iterator Der Zugriff auf Baumelemente der Klasse 'feld' in Tiefe 1 der Verschachtelung erfolgt über einen Iterator der Klasse 'inorder' Der Zugriff auf Feldelemente der Klasse 'char' in Tiefe 2 der Verschachtelung erfolgt über einen zusätzlichen Iterator der Klasse 'LtoR' Die Beschriftung neben dem Zugπffspfeil zeigt die Zuordnung von Iteratoren zu Containern anFIG. 14 shows read and write accesses to nested containers. The tree of class 'tree' is accessed as a whole and therefore without an iterator. Tree elements of class 'field' at depth 1 of the nesting are accessed via an iterator of class 'inorder'. Field elements of class 'char' in Depth 2 of the nesting is done via an additional iterator of the class 'LtoR'. The label next to the arrow indicates the assignment of iterators to containers
Figur 15 zeigt indirekte lesende und schreibende Zugriffe auf einen Container der Klasse 'bäum' und seine Elemente der Klasse 'inf Der Iterator für den 'baum'-Container ist selbst Element eines Containers der Klasse eid' und benotigt daher für den Zugriff seinerseits einen Iterator Alle beteiligten, auch eingebettete, Iteratoren werden durch Kreuzungspunkte auf dem Zugrrffspfeil markiert Die Zuordnung geht aus der Beschattung neben dem Zugrrffspfeil hervor Figur 16 zeigt die dynamische Speicherpiatzzuweisung für ein Objekt der Klasse Objekt' mit Zuweisung der Objektposition an einen Iterator Anschließend erfolgt ein lesender Zugriff auf das dy- namisch erzeugte Objekt über einen Iterator Das Objekt wird wieder geloscht durch Aufruf einer Elementfunktion der DYNAMIC-SpeicherklasseFIG. 15 shows indirect read and write access to a container of the class 'tree' and its elements of the class 'inf. The iterator for the' tree 'container is itself an element of a container of the class eid' and therefore requires an iterator for access All involved, including embedded, iterators are marked by crossing points on the access arrow. The assignment is shown by the shading next to the access arrow. Figure 16 shows the dynamic memory location allocation for an object of the class object 'with assignment of the object position to an iterator the dynamically generated object via an iterator. The object is deleted again by calling an element function of the DYNAMIC storage class
Figur 17 zeigt den Aufruf einer Funktion mit Namen sort und mit drei Argumenten, sowie den Aufruf des Operators '+' mit zwei Argumenten Figur 18 zeigt eine Verschachtelung von Funktions- und Operationsaufrufen 'misch' ist als Ele- mentfunktion mit schreibender Wirkung gekennzeichnet '+=' ist als Eiemeπtoperator mit schreibender und lesender Wirkung gekennzeichnet Das Ergebnis der '%'-Operatιon wird einem Objekt zugewiesen Das Argument des Operators '-' ist ein einfacher Ausdruck, ebenso das zweite Argument des Operators '+=' Figur 19 zeigt eine Kontrollstruktur (C) mit einer Precondition und einem Case vom Typ SELECT (S) Die Precondition repräsentiert den Wert eines Objekts, beispielsweise mit Objektnamen 'a', von dem der Argumentpfeil ausgeht Falls die Konkatenation 'a==1 aus Pre- und Postcoπdition erfüllt ist, wird der Case ausgeführtFigure 17 shows the call of a function with the name sort and with three arguments, and the call of the operator '+' with two arguments. Figure 18 shows a nesting of function and operation calls' mixed 'is marked as an element function with a writing effect' + = 'is identified as an operator with a writing and reading effect. The result of the'% 'operation is assigned to an object. The argument of the operator' - 'is a simple expression, as is the second argument of the operator' + = 'Figure 19 shows a control structure (C) with a precondition and a case of the type SELECT (S) The precondition represents the value of an object, for example with object name 'a', from which the argument arrow is based If the concatenation 'a == 1 from precondition and postcondition is fulfilled , the case is executed
Figur 20 zeigt eine selektive Kontrollstruktur wie oben, jedoch vor der Precondition mit einem aus zwei Operationen bestehenden Prolog Figur 21 zeigt eine selektive Kontrollstruktur wie oben, jedoch mit einem zusatzlichen DEFAULT- Case, der einer else-Anweisung entsprichtFIG. 20 shows a selective control structure as above, but before preconditioning with a prologue consisting of two operations. FIG. 21 shows a selective control structure as above, but with an additional DEFAULT case that corresponds to an else statement
BERICHTIGTES BLATT (REGEL 91) ISA/EP Figur 22 zeigt eine Verschachtelung von selektiven Kontrollstrukturen, die einer rf-then-if-Anwei- sung entsprichtCORRECTED SHEET (RULE 91) ISA / EP FIG. 22 shows a nesting of selective control structures which corresponds to an rf-then-if statement
Figur 23 zeigt eine selektive Kontrollanweisung mit mehreren Cases, darunter einem DEFAULT- Case, die einer switch-case-Anweisung entspricht Figur 24 zeigt zwei repetitive Kontrollanweisungen, die einer while- bzw for-Schlerfe entsprechen Figur 25 zeigt eine gemischt selektive und repetitive Kontrollstruktur mit Prolog, die einem endlichen Automaten entspricht Zu diesem Zweck ist die Kontrollstruktur mit lokalen Objekten zu einer funktionalen Einheit ergänzt Die SELECT-Cases entsprechen den Endzustanden des Automaten Sie enthalten die Aufrufe der Aktionen, die bei Erreichen eines Endzustands auszuführen sind Der DEFAULT-Fall ist repetitiv, fuhrt zum Einlesen eines neuen Ereignisses, beispielsweise aus einer Datei, und zum anschließenden Rucksprung auf die Precondition Im Prolog wird das Ereignisobjekt initialisiert Die Automatentabelle besteht aus einem zwei-dimensionalen Feld mit Elementen der Klasse 'int', die jeweils dem Folgezustand entsprechen Die Precondition ermittelt aus dem neuen Ereignis 'ereig' und dem alten Zustand 'zusf den neuen Zustand eldfzust] [ereig]' und weist ihn dem Zustandsobjekt zuFIG. 23 shows a selective control instruction with several cases, including a DEFAULT case, which corresponds to a switch case instruction. FIG. 24 shows two repetitive control instructions, which correspond to a while or for slack. FIG. 25 shows a mixed selective and repetitive control structure with Prologue, which corresponds to a finite automaton For this purpose, the control structure is supplemented with local objects to form a functional unit. The SELECT cases correspond to the final states of the automaton. They contain the calls to the actions that are to be carried out when an end state is reached. The DEFAULT case is repetitive , leads to the reading of a new event, for example from a file, and a return to the precondition. The event object is initialized in the prologue. The machine table consists of a two-dimensional field with elements of class 'int', each of which corresponds to the subsequent state. The precondition determined from the new event 'ereig' and the old state 'add the new state eldfstatus] [ereig]' and assigns it to the state object
Figur 26 zeigt a) eine horizontale Verschachtelung, b) eine vertikale Verschachtelung und c die Zusammenfassung von a) und b) zu einer Funktionalen EinheitFIG. 26 shows a) a horizontal nesting, b) a vertical nesting and c the combination of a) and b) into a functional unit
Figur 27 zeigt verschiedene Argument-, Element- und Zuweisungsbeziehungen zwischen der ho- nzontalen und der vertikalen Verschachtelung einer Funktionalen Einheit Figur 28 zeigt die hierarchische Anordnung von Funktionen zu Moduln, von Moduln zu Systemebenen und von Systemebenen zu einem Gesamtsystem Die Objekte höherer Funktionaler Einheiten sind jeweils global zu allen ihnen untergeordneten Funktionalen Einheiten und erlauben Zugπffspfeile über mehrere Hierarchiestufen hinweg Figur 29 zeigt die Klassendefinition einer Verketteten Liste mit Namen 'kette' Sie umfaßt eine Konstruktorfunktion, sowie weitere Funktionen zum Einfugen, Loschen und Andern von Listenelementen Die Datenelemente der Klasse umfassen eine dynamische Speicherdeklaration für STRUKTUR-Objekte der Klasse 'emtrag', sowie einen Iterator namens erst' 'erst', sowie der Iterator 'nächst' dienen der Verkettung der Listenelemente Die Elementfunktionen von 'kette weisen sowohl Zugriffe auf ihre lokalen Objekte auf, als auch globale Zugriffe auf die Datenelemente von 'kette'.FIG. 27 shows various argument, element and assignment relationships between the horizontal and the vertical nesting of a functional unit. FIG. 28 shows the hierarchical arrangement of functions to modules, from modules to system levels and from system levels to an overall system. The objects of higher functional units are each globally to all subordinate functional units and allow access arrows across several hierarchical levels Figure 29 shows the class definition of a linked list with the name 'chain'. It includes a constructor function, as well as other functions for inserting, deleting and changing list elements. The data elements of the class include one dynamic memory declaration for STRUCTURE objects of the class 'emtrag', as well as an iterator named '' first ', and the iterator' next 'serve to concatenate the list elements. The element functions of' chain have access to their local objects as well as also global access to the data elements of 'chain'.
Figur 30 zeigt eine Abstraktion der Klassendefinition nach Figur 29 Von den Elementfunktionen sind alle Details bis auf ihre globalen Zugriffe auf die Datenelemente verdeckt Von den Datenelementen sind die Details der Listenobjekte verdeckt Figur 31 zeigt eine Vergroberung der Klassendefinition nach Figur 29 Zusätzlich zu den in der Ab- straktion nach Figur 30 verdeckten Details ist, willkürlich, der Iterator 'erst' verdeckt, sowie alle Zugriffe der Elementfunktionen daraufFIG. 30 shows an abstraction of the class definition according to FIG. 29. All details of the element functions are hidden except for their global access to the data elements. The data elements hide the details of the list objects. FIG. 31 shows a coarsening of the class definition according to FIG. 29 - The traction according to FIG. 30 is hidden details, arbitrarily, the iterator is 'first' hidden, as well as all accesses of the element functions to it
Figur 32 zeigt eine Klassenhierarchie Die Basisklasse 'A' besitzt die Elementfunktionen 11 ' und 12', sowie einen Container mit Iterator als Datenelemente Von 'A' sind die Klassen 'B' und 'C abgeleitet, die jeweils die Funktion 11 ' neu definieren Von 'C sind wiederum die Klassen 'D' und 'E' abgeleitet, die jeweils die Funktionen 11' und 12' der Oberklassen neu definieren Alle von 'CFIG. 32 shows a class hierarchy. The base class 'A' has the element functions 11 'and 12', as well as a container with an iterator as data elements. The classes 'B' and 'C are derived from' A 'and each redefine the function 11' From 'C, the classes' D 'and' E 'are derived, which redefine the functions 11' and 12 'of the upper classes. All of' C
BERICHTIGTES BLATT (REGEL 91) ISA/EP abgeleiteten Klassen haben Zugriff auf ihre eigenen Datenelemente wie auch auf die ihrer OberklassenCORRECTED SHEET (RULE 91) ISA / EP derived classes have access to their own data elements as well as those of their superclasses
5.4 Speicherabbild5.4 Memory image
Das auf dem Bildschirm angezeigte visuelle Programm besitzt im Arbeitsspeicher der Program- mierplattform ein Speicherabbild in Form einer komplexen Datenstruktur Dieses Speicherabbild ist gemeinsame Grundlage der unterschiedlichen Funktionen der Programmierumgebung, wie z.B das Editieren, die graphische Wiedergabe oder die Übersetzung in eine textuelle ProgrammierspracheThe visual program displayed on the screen has a memory image in the form of a complex data structure in the working memory of the programming platform. This memory image is the common basis of the various functions of the programming environment, such as editing, graphic reproduction or translation into a textual programming language
Das Speicherabbild des visuellen Programms besitzt, wie das visuelle Programm selbst, eine Baumstruktur Jedem Baumelement des visuellen Programms ist dabei ein Speicher-Objekt zugeordnet, das gemäß seiner Inklusions- und Nachbarschaftsbeziehungen, sowie seiner Benutzungsund Kommunikationsbeziehungen, mit anderen Speicher-Objekten verkettet istThe memory image of the visual program, like the visual program itself, has a tree structure. Each tree element of the visual program is assigned a memory object which is linked to other memory objects in accordance with its inclusion and neighborhood relationships, as well as its usage and communication relationships
Die Objekte des Speicherabbilds sind dabei in Klassen eingeteilt, die den unterschiedlichen Pro- grammbausteinen entsprechen Unter den Datenelementen jeder dieser Klassen befinden sich neben den Verkettungsva ableπ auch jene Attribute, welche die unterschiedlichen Funktionen der Programmierumgebung unterstutzen, wie z.B Geometrie-Daten, Farbcodes, Klassen- und Objektnamen, Funktionsnamen und Operationssymbole, arithmetische Konstanten, Dokumentations- texte, Projektdaten und TestwerteThe objects of the memory image are divided into classes that correspond to the different program modules. In addition to the chaining variables, the data elements of each of these classes also contain attributes that support the different functions of the programming environment, such as geometry data, color codes, classes - and object names, function names and operation symbols, arithmetic constants, documentation texts, project data and test values
Die Traversierung des Speicherabbilds erfolgt in der Regel rekursiv mithilfe virtueller Funktionen Dabei wird automatisch für jedes besuchte Objekt des Speicherabbilds eine vom Typ des Objekts abhangige Implementierung einer virtuellen Funktion aufgerufen Diese greift, abhangig vom be- suchten Objekttyp und der gewünschten Funktion der Programmierumgebung, auf Attribute des Objekts zu, um ihren Anteil an der jeweiligen Funktion der Programmierumgebung, wie z B Editieren oder Übersetzen, beizutragenThe memory image is usually traversed recursively using virtual functions. For each visited object of the memory image, an implementation of a virtual function that is dependent on the type of the object is called up. This, depending on the type of object visited and the desired function of the programming environment, accesses attributes of the object in order to contribute to the respective function of the programming environment, such as editing or translation
5.5 Programmierumgebung5.5 Programming environment
Für die Anwendung des erfindungsgemaßen Verfahrens auf die Konstruktion von Programmen ist es notig, verschiedene Arbeitsfunktionen zu unterscheiden, die sich erganzen und erst in ihrem systematischen Zusammenwirken die Konstruktion ermöglichen Alle diese Arbeitsfunktionen operieren auf dem gemeinsamen Speicherabbild des visuellen Programmsystems Es handelt sich dabei um die Funktionen des Erstellens und Veranderns des Speicherabbilds, um die Übersetzung des Speicherabbilds in eine textuelle oder andere Programmiersprache, um die Verlagerung des Speicherabbilds von und zu einem nicht-fluchtigen Speichermedium, um die Generierung graphischer Darstellungen aus dem Speicherabbild, um die Dokumentation und die Verwaltung des Speicherabbilds, um die Navigation durch das Speicherabbild und um die Animation der graphischen Darstellung des SpeicherabbildsFor the application of the method according to the invention to the construction of programs, it is necessary to differentiate between different work functions that complement each other and only allow construction in their systematic interaction. All these work functions operate on the common memory image of the visual program system. These are the functions creating and modifying the memory map, translating the memory map into a textual or other programming language, relocating the memory map from and to a non-volatile storage medium, generating graphics from the memory map, documenting and managing the Memory map, to navigate through the memory map and to animate the graphical representation of the memory map
55 1 Editor55 1 Editor
Die Aufgabe, das Speicherabbild eines visuellen Programms zu erstellen oder zu verandern, wird erfindungsgemaß dadurch gelost, a) daß unmittelbar in dem auf einem Ausgabemedium angezeigten visuellen Programm mithilfe eines graphischen Eingabewerkzeugs Einfuge-, Anderungsund Loschoperationen ausgelost werden können, b) daß in Abhängigkeit von der Einfuge-, Ande- rungs- und Loschposition innerhalb des visuellen Programms die Menge der möglichen Aktionen und Eingaben sinnvoll eingeschränkt und dies dem Programmierer angezeigt wird, c) daß in Abhängigkeit von der Einfuge-, Anderungs- und Loschposition innerhalb des visuellen Programms dem Programmierer zusatzliche Hilfsinformationen angezeigt werden und d) daß die Objekte des Speicherabbilds des visuellen Programms mit Informationen zur Unterstützung des Verfahrens nach a) bis c) angereichert werdenThe task of creating or changing the memory map of a visual program is achieved according to the invention in that a) that inserting, changing and deleting operations can be triggered directly in the visual program displayed on an output medium with the aid of a graphic input tool, b) that depending on the insertion, modification and deletion position within the visual program meaningfully limits the number of possible actions and inputs and this is indicated to the programmer, c) that depending on the insertion, modification and deletion position within the visual program the programmer additional auxiliary information is displayed and d) that the objects of the memory image of the visual program are enriched with information to support the method according to a) to c)
Die Erstellung oder Veränderung eines visuellen Programms nach dem hier beschriebenen Verfahren erfolgt unmittelbar auf seiner visuellen Darstellung auf dem Bildschirm der Programmier- plattform Dazu sind für jeden Programmbaustein sogenannte C ck-Zonen definiert, in welche mithilfe einer Rollkugel ("Maus") der Cursor gefuhrt wird und wo durch Betätigung der verschiedenen Tasten der Rollkugel neue Programmbausteine eingefugt oder vorhandene geloscht oder neu spezifiziert werden können (siehe Figur 33)The creation or modification of a visual program according to the procedure described here takes place directly on its visual representation on the screen of the programming platform. For this purpose, so-called Cck zones are defined for each program block, into which the cursor is guided using a trackball ("mouse") and where new program modules can be inserted or existing ones can be deleted or re-specified by pressing the various buttons on the trackball (see Figure 33)
Beim Einfügen in "drag-and-drop' -Technik kann der einzufugende Programmbaustein aus einer Randleiste des Bildschirms gelost und entfernt davon zunächst abgelegt werden Ein anschließender Click an der Einfugeposition fuhrt zum Einfugen falls der einzufugende Baustein den Bedingungen der Einfugeposition genügt Eine solche Bedingung kann beispielsweise Typkonsistenz sein oder generelles Verbot des Einfugens für einen Bausteintyp an dieser Position Im Fehlerfall wird Hilfsinformation angezeigtWhen inserting using the "drag-and-drop" technique, the program block to be inserted can be removed from an edge bar on the screen and removed from it initially. A subsequent click at the insertion position leads to insertion if the block to be inserted satisfies the conditions of the insertion position For example, be type consistent or general prohibition of inserting a block type at this position. In the event of an error, help information is displayed
Bei der Spezifikation eines vorhandenen Programmbausteins fuhrt ein Click in der Zone zur Beschriftung des Bausteins zur Anzeige eines Fensters mit zulassigen Beschriftungen Beispielsweise erscheint bei der Spezifikation eines Containernamens nur die Liste der verfugbaren Containertypen, bei der Spezifikation einer Traverse auf einem Container nur die Traversentypen, die für diesen Containertyp definiert sind, bei der Spezifikation einer Elementfunktion nur die Namen derjenigen Funktionen, die für diesen Objekttyp definiert sind, usw Die Auswahlmoglichkeiten sind dabei jeweils von der bisherigen Spezifikation abhangig Die Auswahl eines Listenelements erfolgt durch Anklicken (siehe Figur 34)When specifying an existing program block, a click in the zone to label the block displays a window with permitted labels.For example, when specifying a container name, only the list of available container types appears; when specifying a truss on a container, only the truss types that appear are defined for this container type, when specifying an element function only the names of those functions that are defined for this object type, etc. The selection options are dependent on the previous specification. The selection of a list element is done by clicking (see Figure 34)
Die vom Editor selektiv angebotenen Namen für Operanden und Operationen können einerseits im Zuge der Definition neuer Operanden und Operationen entstehen andererseits kann der Editor mit Namenslisten konfiguriert werden, die von außen zugeführt werden Dazu ist es sinnvoll, existierende Klassenbib otheken der Zielsprache durch eine Syntaxanalyse automatisch auszuwerten und zu klassifizierenThe names for operands and operations selectively offered by the editor can arise on the one hand in the course of the definition of new operands and operations on the other hand the editor can be configured with name lists that are supplied from the outside. It makes sense to automatically evaluate and classify existing class libraries of the target language using a syntax analysis
Die Spezifikation von Beziehungen zwischen Operationen und Operanden kann in "rubber-ban- dιng"-Technιk erfolgen Dabei wird der Cursor von der entsprechenden Click-Zone des Operators bis zum Operanden bewegt, die Taste der Rollkugel beim Start gedruckt und am Ziel losgelassen Währenddessen wird die vom Cursor zurückgelegte Strecke farblich markiert Beim Drucken der Taste kann zusätzliche Hilfsinformation angezeigt werden, wie z B die farblich hervorgehobene Beschriftung aller zulassigen Zielobjekte an der möglichen Zielposition, mit Emruckung entsprechend der SchachtelungstiefeRelations between operations and operands can be specified in the "rubber-band" technology. The cursor is moved from the corresponding click zone of the operator to the operand, the button on the trackball is printed at the start and released at the destination the distance covered by the cursor is highlighted in color When the button is pressed, additional auxiliary information can be displayed, such as the color-coded labeling of all permitted target objects at the possible target position, with printing according to the nesting depth
Die Spezifikation der Zuordnung einer Traverse zu einem Container kann ebenfalls in "rubber-ban- dιng"-Technιk erfolgen Dabei ist der Startpunkt des Cursors der Kreuzungspunkt eines Bezieh- ungs-Pfeils mit einem Iterator Der Zielpunkt liegt auf dem Container und wird beim Loslassen der Taste mit dem Objektnamen des zugeordneten Iterators beschriftet Der Kreuzungspunkt von Pfeil und Iterator wird mit einer Kreuzungsmarke belegtThe specification of the assignment of a traverse to a container can also be done in "rubber-banding" technology. The starting point of the cursor is the crossing point of a relationship arrow with an iterator. The target point lies on the container and is released when the Key labeled with the object name of the assigned iterator. The intersection of the arrow and the iterator is assigned a crossing mark
Jede Spezifikation wird unmittelbar in das Speicherabbild des visuellen Programms übernommen Einfugen und Loschen fuhren ebenfalls zu einer sofortigen Änderung aller Abmessungen und Positionen der betroffenen Elemente des visuellen Programms Unter den Attributen eines jeden Objekts des Speicherabbilds befinden sich seine Koordinaten seine Abmessungen und seine Farbe Zur Ermittlung des Objekts, auf dem sich der Cursor befindet wird das Speicherabbild unter Vergleich der Objektkoordinaten mit den Cursorkoordinaten traversiert, bis das Objekt unter dem Cursor erreicht istEach specification is immediately transferred to the memory image of the visual program. Inserting and deleting also leads to an immediate change of all dimensions and positions of the elements of the visual program concerned.At the attributes of each object of the memory image are its coordinates, its dimensions and its color The object on which the cursor is located is traversed by comparing the object coordinates with the cursor coordinates until the object under the cursor is reached
Editier-BeispieleEditing examples
Figur 33 zeigt eine Funktion mit zwei Argumenten und den Click-Zonen A bis F, sowie einen Con- tainer mit Iterator und Elementen vom Typ STRUKTUR mit wiederum zwei Struktur-Elementen und den Click-Zonen A bis D Im SPECIFY-Modus fuhrt ein Click in Zone B der Funktion mit anschließendem Ziehen des Cursors in Zone B eines Objekts zur Definition einer Elementbeziehung mit entsprechendem L-Pfeil Ein Click in Zone A der Funktion fuhrt zum Offnen eines Fensters zur Eingabe des Funktionsnamens Falls bereits eine Elementbeziehung zu einem Objekt besteht, enthalt das Fenster nur eine Namensiiste von Elementfunktionen dieses Objekts Ein Click in Zone C der Funktion fuhrt zum Offnen eines Fensters zur Auswahl bzw Eingabe von Konstanten Zone D der Funktion ist analog zu Zone B für die Definition von Argumentbeziehungen bestimmt, ebenso Zone F für Zuweisungsbeziehungen Ein Click in Zone A eines Objekts fuhrt zum Offnen eines Fensters zur Auswahl von Klassennamen bzw zur Eingabe von Objektnamen Je nach Typ des Objekts werden nur die verfugbaren SKALAR- STRUKTUR-, CONTAINER- oder ITERATOR- Klassen zur Auswahl angeboten Falls zwischen Iterator und Container bereits eine Zuordnung be- steht, werden nur die für diesen Container definierten Iteratorklassen angeboten. Eine Zuordnung zwischen Iterator und Container wird festgelegt durch einen Click in Zone C der Uberkreuzung von Iterator und Reil, sowie anschließendem Ziehen des Cursors in Zone B des Containers Im INSERT-Modus fuhrt, nachdem das einzufugende Programmelement bestimmt ist, ein Click in die Zonen A+B, E oder F einer Funktion zum Einfugen des Programmelementes an der bezeichneten Stelle Ebenso fuhrt ein Click in die Zonen A+B oder D einer vertikalen Verschachtelung zum Einfugen eines vorher bestimmten Objekts an der bezeichneten Stelle Im DELETE-Modus fuhrt ein Click an beliebiger Position eines Programmelementes zum Verschwinden des Programmelementes und beim Loslassen der Maustaste zum endgültigen Loschen Figur 34 zeigt die graphische Benutzeroberflache des Editors mit einigen visuellen Programmelementen und einem Auswahlfenster für die Spezifikation der Traverse für einen Container der Klasse 'contl ' Dabei enthalt die Auswahlliste nur solche Traversen, die für die Containerklasse 'contl ' definiert sindFIG. 33 shows a function with two arguments and the click zones A to F, as well as a container with an iterator and elements of the STRUCTURE type with again two structure elements and the click zones A to D In the SPECIFY mode, a click is performed in zone B of the function with subsequent dragging of the cursor in zone B of an object to define an element relationship with the corresponding L-arrow. A click in zone A of the function opens a window for entering the function name. If an element relationship already exists to an object, contains The window is only a list of element functions of this object. A click in zone C of the function opens a window for the selection or input of constants. Zone D of the function is defined for zone B in the same way as zone B, as is zone F for assignment relationships in zone A of an object leads to the opening of a window for the selection of class names or for the input of object names depending on the type of object, only the available SCALAR STRUCTURE, CONTAINER or ITERATOR classes are offered for selection If there is already an assignment between iterator and container only the iterator classes defined for this container are offered. An assignment between iterator and container is determined by a click in zone C of the crossover of iterator and reil, and then dragging the cursor into zone B of the container. In INSERT mode, after the program element to be inserted is determined, a click leads to zones A + B, E or F of a function for inserting the program element at the designated position Likewise, a click leads to zones A + B or D of a vertical nesting for inserting a previously determined object at the designated position. In DELETE mode, a click leads to any one Position of a program element for the disappearance of the program element and when releasing the mouse button for the final deletion. Figure 34 shows the graphical user interface of the editor with some visual program elements and a selection window for the specification of the traverse for a container of the class 'contl'. The selection list contains only such traverses that for the container class e 'contl' are defined
552 Compiler552 compiler
Die Aufgabe, das Speicherabbild eines visuellen Programms in den Quellcode einer textuellen Programmiersprache zu übersetzen, wird erfindungsgemaß dadurch gelost, a) daß das Speicherabbild des visuellen Programms in einer Traverse durchlaufen wird, die der sequentiellen Klam- merdarstellung des Objektbaumes entspricht, b) daß für jedes traversierte Objekt des Speicherabbildes gemäß seiner Klasse eine Methode aufgerufen wird, die seine Attribute auf syntaktische Elemente einer Zielsprache bzw auf administrative Einheiten eines Betriebssystems abbildet, c) daß Klassen und ihnen untergeordnete funktionale Einheiten in den Quellcode einer Zielsprache übersetzt werden, d) daß Module und ihnen übergeordnete funktionale Einheiten in administrative Einheiten eines Betriebssystems übersetzt werden, und e) daß die Objekte des Speicherabbilds mit Informationen zur Unterstützung des Verfahrens nach a) bis d) angereichert werdenThe task of translating the memory image of a visual program into the source code of a textual programming language is achieved according to the invention in that a) the memory image of the visual program is traversed in a traverse which corresponds to the sequential bracketed representation of the object tree, b) that for each traversed object of the memory image is called a method according to its class, which maps its attributes to syntactic elements of a target language or to administrative units of an operating system, c) that classes and subordinate functional units are translated into the source code of a target language, d) that modules and higher-level functional units are translated into administrative units of an operating system, and e) that the objects of the memory image are enriched with information to support the method according to a) to d)
Die Übersetzung eines visuellen Programms in den Quellcode einer textuellen Programmiersprache nach dem hier beschriebenen Verfahren beruht auf einer Traverse, die geeignet ist, die Baumstruktur des Speicherabbildes auf eine lineare Klammerstruktur abzubilden Die Traverse kann sich auch auf einzelne Teilbaume beschranken, die funktionalen Einheiten entsprechen Die Traverse wird vorzugsweise rekursiv durchgeführt, wobei virtuelle Methoden aller Objekt-Klassen des Speicherabbildes an der Rekursion beteiligt sindThe translation of a visual program into the source code of a textual programming language according to the procedure described here is based on a traverse that is suitable for mapping the tree structure of the memory image onto a linear bracketed structure. The traverse can also be limited to individual subtrees that correspond to functional units. The traverse is preferably carried out recursively, virtual methods of all object classes of the memory image being involved in the recursion
Klassen-, Funktions- und Operationsdefinitionen, sowie untergeordnete Einheiten werden jeweils in die kontextfreien Satzstrukturen der Zielsprache übersetzt Dabei wird der Objektbaum der Operanden entweder auf einen Deklarationsteil abgebildet oder auf Datenelemente einer Klasse Der Baum der Operationen wird auf Funktions- oder Operationsaufrufe mit, möglicherweise verschachtelten, Ausdrucken als Argumenten abgebildet Argument-, Element- und Zuweisungsbe- Ziehungen werden im einfachsten Fall auf Objektnamen, Element- bzw Zuweisungssymbole abgebildet Zugriffe auf verschachtelte Strukturen werden auf Radbeschreibungeπ mit möglicher- weise mehreren Komponenten abgebildet Zugriffe auf Container über Iteratoren werden im allgemeinen Fall auf eine kontextfreie Klammerungsstruktur abgebildetClass, function and operation definitions, as well as subordinate units are translated into the context-free sentence structures of the target language. The object tree of the operands is either mapped to a declaration part or to data elements of a class. The tree of operations is nested with function or operation calls , Printout mapped as arguments. In the simplest case, argument, element and assignment relationships are mapped to object names, element or assignment symbols. Access to nested structures is assigned to wheel descriptions with possible Multiple components mapped Accesses to containers via iterators are generally mapped to a context-free compound structure
Für die einheitliche Behandlung von Zugriffen auf Container unterschiedlichster Art wird für jeden Container der Q-Operator überladen Sem Returnwert ist eine Referenz auf das adressierte Container-Element und kann somit sowohl auf der linken (schreibend) als auch auf der rechten Seite (lesend) einer Zuweisung stehen Parameter des O-Operators ist jeweils ein Iterator aus einer Unterklasse der dem jeweiligen Container zugeordneten Iteratorklasse Die Kreuzungsmarke visua siert die Auswahl des Iterators, der als Parameter für den Q-Operator verwendet wird. Der allge- meine Containerzugriff erfolgt somit analog zum herkömmlichen Zugriff auf Feldelemente über den Q-Operator und einen Indexwert. Bei der Parameterubergabe können Konsistenzprufungen vorgenommen werden und Maßnahmen zur Verbesserung der Performance, wie z.B. Caching, ergriffen werdenFor the uniform handling of access to containers of various types, the Q operator is overloaded for each container. Sem return value is a reference to the addressed container element and can therefore be on the left (writing) as well as on the right (reading) one Assignment are parameters of the O operator is an iterator from a subclass of the iterator class assigned to the respective container. The crossing mark visualizes the selection of the iterator that is used as a parameter for the Q operator. General container access is therefore analogous to conventional access to field elements using the Q operator and an index value. When passing parameters, consistency checks can be carried out and measures to improve performance, such as Caching to be taken
Module, Komponenten, Systemebenen, Systeme und sonstige höhere funktionale Einheiten, für die kein direktes Gegenstuck in der Zielsprache existiert, werden in administrative Einheiten des Betriebssystems der Zielplattform übersetzt Hierzu zahlen Verzeichπisstrukturen, die als Produktbaum des generierten, textuellen Quellprogramms betrachtet werden können, zusammen mit den ihnen zugeordneten, sogenannten "Make-Files", die administrative Anweisungen zur Struktune- rung des Systems enthalten Damit kann der aus den Klassen-, Funktions- und Operationsdefinitionen generierte Quellcode weiter strukturiert und zu höheren funktionalen Einheiten zusammengefaßt werden Solche Einheiten sind beispielsweise textuelle Funktionsbibliotheken, aber auch sogenannte "Header-Files" zur Zusammenlegung von Klassendefinitionen, zusammen mit weiteren Dateien, welche die Definitionen der Elementfunktionen enthalten Eine weitere hierarchi- sehe Anordnung des generierten Quellcodes kann direkt auf die Verzeichnisstruktur abgebildet werden, wobei für jedes Verzeichnis ein passendes Makefile generiert wirdModules, components, system levels, systems and other higher functional units, for which there is no direct counterpart in the target language, are translated into administrative units of the operating system of the target platform. This includes directory structures that can be viewed as the product tree of the generated, textual source program together with the so-called "make files" assigned to them, which contain administrative instructions for structuring the system. The source code generated from the class, function and operation definitions can thus be further structured and combined into higher functional units. Such units are, for example, textual function libraries , but also so-called "header files" for merging class definitions, together with other files containing the definitions of the element functions. A further hierarchical arrangement of the generated source code can be directly related to the directory map structure, whereby a suitable makefile is generated for each directory
Für die Umsetzung der Objekte des Speicherabbilds in strukturierten Quellcode ist es notig, die Objekte mit zusatzlichen Informationen anzureichern, die teils direkt vom Benutzer beim Editieren eingetragen werden, teils wahrend des Editierens oder auch wahrend des Ubersetzungsvorgangs automatisch erzeugt werden Vom Benutzer werden beispielsweise Klassen- und Funktionsnamen, Operationssymbole und Konstanten mithilfe des Editors eingegeben, wahrend Objektnamen auch automatisch generiert werden können Die Spezifikation eines Zugriffs auf Container über Iteratoren durch den Benutzer fuhrt automatisch zur Erzeugung von Strukturinformation über den gesamten Zugriffsweg, der Verschachtelungen und Einbettungen von Iteratoren enthalten kann Diese Information wird beim Ubersetzungsvorgang ausgewertetFor the conversion of the objects of the memory image into structured source code, it is necessary to enrich the objects with additional information, some of which are entered directly by the user during editing, some of which are automatically generated during editing or during the translation process Function names, operation symbols and constants are entered using the editor, while object names can also be generated automatically.The specification of access to containers via iterators by the user automatically leads to the generation of structural information about the entire access path, which can contain nesting and embedding of iterators.This information will evaluated during the translation process
Bei der Übersetzung des Speicherabbildes kann, in den generierten Quellcode eingestreut, zusätzlicher Code erzeugt werden, der zur Laufzeit auf die Objekte des Speicherabbildes zugreift, um dort Informationen für Test, Fehlersuche oder Animation abzulegen Dazu sind die Klassen der Speicherobjekte mit weiteren Attributen anzureichern Im Einzelnen werden die Programmbausteine der in 5 3 exemplarisch angegebenen visuellen Programmiersprache wie folgt, und ebenfalls exemplarisch, in die Zielsprache C++ übersetzt-When translating the memory image, interspersed in the generated source code, additional code can be generated that accesses the objects of the memory image at runtime in order to store information there for testing, troubleshooting or animation. For this purpose, the classes of the memory objects must be enriched with further attributes In detail, the program modules of the visual programming language exemplified in 5 3 are translated as follows, and also exemplarily, into the target language C ++.
Ubersetzunas-BeispieleExamples of translation
Figur 35 zeigt ein skalares Objekt mit Klassenamen 'int', Objektnamen ϊ und Anfangswert '0'.Figure 35 shows a scalar object with class name 'int', object name ϊ and initial value '0'.
Übersetzung in "int ι=0;"Translation into "int ι = 0;"
Figur 36 zeigt eine Struktur mit Strukturnamen 'datum', Objektnamen 'd' und seinen offengelegten Strukturelementen Übersetzung in "datum d,"FIG. 36 shows a structure with structure name 'datum', object name 'd' and its disclosed structural elements. Translation into "datum d,"
Figur 37 zeigt eine Struktur mit Strukturnameπ 'emtrag' und Objektnamen 'p', deren erstes, unspe- zrfiziertes, Strukturelement vom Typ 'STRUCTURE' durch eine Struktur der Klasse 'datum' ersetzt wurde. Übersetzung in die Template-Deklaration "eιntrag<datum> p;" Figur 38 zeigt einen Container mit Klassennamen eid' und Objektnamen 'a', welcher Objekte der Klasse 'typ' enthält Übersetzung in die Template-Deklaration "feld<typ> a;". Eine zusatzliche Großenangabe in der Spezifikation des Containers kann auf einen weiteren Template-Parameter abgebildet werdenFIG. 37 shows a structure with structure name π 'emtrag' and object name 'p', the first, unspecified structure element of the type 'STRUCTURE' has been replaced by a structure of the class 'datum'. Translation into the template declaration "entry <date> p;" Figure 38 shows a container with class name eid 'and object name' a ', which contains objects of class' type'. Translation into the template declaration "field <typ> a;". An additional size specification in the specification of the container can be mapped to another template parameter
Figur 39 zeigt einen Container mit Klasseπnamen leid' und Objektπamen 'a', welcher wiederum Objekte der Klasse leid' enthalt, die jeweils Objekte der Klasse 'typ' enthalten. Übersetzung in die verschachtelte Template-Deklaration "feld<feld<typ» a".Figure 39 shows a container with class names sorry 'and object names' a', which in turn contains objects of class sorry, each containing objects of class' type '. Translation into the nested template declaration "field <field <type» a ".
Figur 40 zeigt zwei skalare Objekte mit Objektnamen 'a' und 'b', sowie eine Zuweisung von 'a' nach 'b'. Übersetzung in "a=b,"Figure 40 shows two scalar objects with object names 'a' and 'b', as well as an assignment from 'a' to 'b'. Translation into "a = b,"
Figur 41 zeigt zwei skalare Objekte mit den Klassennamen 'cart' bzw. 'polar' und den Objektnamen 'c' bzw 'p', sowie einer Zuweisung mit Cast-Anpassung Übersetzung in "c=(cart)p" oder "c=cart(p)"Figure 41 shows two scalar objects with the class names 'cart' or 'polar' and the object names 'c' or 'p', as well as an assignment with cast adaptation translation into "c = (cart) p" or "c = cart (p) "
Figur 42 zeigt vier skalare Objekte mit den Objektnamen 'a', 'b', 'c' und 'd', sowie den Aufruf einer Elementfunktion von 'a' mit dem Funktionsnamen 1'. 'b' und 'c' sind Eingabeparameter von T Das Ergebnis des Aufrufs wird an 'd' zugewiesen. Übersetzung in "d=a f(b,c)". Figur 43 zeigt vier skalare Objekte mit den Objektnamen 'a', 'b', 'c' und 'd', sowie den Aufruf eines Elementoperators von 'a' mit dem Operatorsymbol '*'. 'b' und 'c' sind Eingabeparameter von '*'. Das Ergebnis der Operation wird an 'd' zugewiesen. Übersetzung in "d=a.operator*(b, c)," Figur 44 zeigt vier skalare Objekte mit den Objektnamen 'a', 'b', 'c' und 'd', sowie zwei Aufrufe von Funktionen mit den Namen T bzw 'g' 'g' besitzt die beiden Eingabeparameter 'b' und 'c' T besitzt den Eingabeparameter 'ä, sowie als zweiten Eingabeparameter das Ergebnis des Funktions- aufrufs von 'g' Übersetzung in "d=f(a,g(b,c));"FIG. 42 shows four scalar objects with the object names' a ',' b ',' c 'and' d ', and the call of an element function from' a 'with the function name 1'. 'b' and 'c' are input parameters of T The result of the call is assigned to 'd'. Translation into "d = a f (b, c)". Figure 43 shows four scalar objects with the object names 'a', 'b', 'c' and 'd', as well as the call of an element operator from 'a' with the operator symbol '*'. 'b' and 'c' are input parameters of '*'. The result of the operation is assigned to 'd'. Translation into "d = a.operator * (b, c)," Figure 44 shows four scalar objects with the object names 'a', 'b', 'c' and 'd', as well as two calls of functions with the name T or 'g' 'g' has the two input parameters' b 'and' c 'T has the input parameter' ä, and as a second input parameter the result of the function call of 'g' translation into "d = f (a, g ( b, c)); "
Figur 45 zeigt vier skalare Objekte mit den Objektnamen 'a', 'b', 'c' und 'd', sowie einem verschachtelten Aufruf von zwei Funktionen mit den Namen 1' und 'g' Die Eingabeparameter von 'g' sind 'a' und 'b' Der Eingabeparameter von 1' ist das Ergebnis des Funktionsaufrufs von 'g', das zusatzlich einem Objekt mit Namen 'c' zugewiesen wird Das Ergebnis des Funktionsaufrufs von 1' wird einem Objekt namens 'd' zugewiesen Übersetzung in "d=f(c=g(a,b)),"Figure 45 shows four scalar objects with the object names 'a', 'b', 'c' and 'd', as well as a nested call of two functions with the names 1 'and' g '. The input parameters of' g 'are' a 'and' b 'The input parameter of 1' is the result of the function call of 'g', which is additionally assigned to an object with the name 'c' The result of the function call of 1 'is assigned to an object called' d 'Translation into "d = f (c = g (a, b)), "
BERICHTIGTES BLATT (REGEL 91) ISA/EP Figur 46 zeigt eine Struktur mit dem Objektπamen 's1\ welche Strukturelemeπte mit den Objektnamen 'a', 'b' und 's2' besitzt 's2' ist selbst eine Struktur und besitzt die Strukturelemente mit Namen 'c' und 'd' Der lesende und schreibende Zugriff auf 'b' wird übersetzt in "s1 b" Der lesende und schreibende Zugriff auf 'c' wird übersetzt in "s1 s2 c" Figur 47 zeigt einen Container mit dem Klasseπnamen 'bäum' und dem Objektnamen 't', der Objekte der Klasse 'typ' enthalt. Der lesende und schreibende Zugriff auf den Container als Ganzes wird übersetzt in TCORRECTED SHEET (RULE 91) ISA / EP Figure 46 shows a structure with the object name 's1 \ which structure elements with the object names'a','b' and 's2' has. 'S2' is itself a structure and has the structure elements with names' c 'and' d 'The reader and write access to 'b' is translated into "s1 b" The read and write access to 'c' is translated into "s1 s2 c" Figure 47 shows a container with the class name 'tree' and the object name 't', the Contains objects of the class 'type'. Read and write access to the container as a whole is translated into T
Figur 48 zeigt einen Container mit dem Klassennamen 'bäum' und dem Objektnamen 't\ der Objekte der Klasse 'typ' enthält, sowie einen Iterator mit Klasseπnamen 'itr' und Objektnamen Y Der lesende und schreibende Zugriff auf ein Contamerelement an der durch Y spezifizierten Position wird übersetzt in "t[i]"Figure 48 shows a container with the class name 'tree' and the object name 't \ which contains objects of the class' type', as well as an iterator with class name 'itr' and object name Y The read and write access to a contamer element at the one specified by Y. Position is translated into "t [i]"
Figur 49 zeigt einen Container mit Klassennamen eid' und Objektnamen 'a', welcher Objekte der Klasse 'bäum' enthält, die jeweils Objekte der Klasse 'typ' enthalten. Dem äußeren Container ist ein Iterator mit Klassennamen 'itrV und Objektnamen Y zugeordnet. Dem inneren Container ist ein Iterator mit Klassennamen 'ιtr2' und Objektnamen 'k' zugeordnet Der lesende und schreibende Zugriff auf ein Element der Containerverschachtelung an der durch Y und 'k' spezifizierten Position wird übersetzt in "a[ι][k]"Figure 49 shows a container with class name eid 'and object name' a ', which contains objects of the class' tree', each of which contains objects of the class' type '. An iterator with class name 'itrV and object name Y is assigned to the outer container. The inner container is assigned an iterator with class name 'ιtr2' and object name 'k'. Read and write access to an element of the container nesting at the position specified by Y and 'k' is translated into "a [ι] [k]"
Figur 50 zeigt zwei Container mit den Klassennamen leid' bzw. 'bäum' und den Objektnamen 'a' bzw 'f. 'a' enthalt Iterator-Objekte der Klasse 'ιtr2', die dem Container 't' zugeordnet sind. Dem Container 'a' ist ein Iterator mit Klassennamen 'ιtr1 ' und Objektnamen Y zugeordnet. Der indirekte lesende und schreibende Zugriff auf ein Element des Containers 't' an der durch den Iterator 'a[i]' spezifizierten Position wird übersetzt in "t[a[i]]"Figure 50 shows two containers with the class names' sorry 'and' tree 'and the object names' a' and 'f. 'a' contains iterator objects of class 'ιtr2' which are assigned to container 't'. An iterator with class name 'ιtr1' and object name Y is assigned to container 'a'. Indirect read and write access to an element of container 't' at the position specified by iterator 'a [i]' is translated into "t [a [i]]"
Figur 51 zeigt einen sowohl indirekten als auch verschachtelten Zugriff auf Elemente eines Containers mit Objektnamen lc4' Die 'c4' zugeordneten Iteratoren 'ι4' sind Elemente der Containerver- schachtelung 'c3' und 'c2' Die diesen Containern zugeordneten Iteratoren 'ι3' und 'ι2' sind Elemente von Strukturen, die in einem Container mit Objektnamen 'd' enthalten sind. Diesem Container ist der Iterator 'ιV zugeordnet. Der indirekte und verschachtelte, lesende und schreibende Zugriff auf ein Element von 'c4' wird übersetzt in "c4[c2[c1 [ι1].ι2][c1 [ι1] ι3]]" Figur 52 zeigt eine selektive Kontrollstruktur mit einer Pre-Condition, die dem Wert des Objekts 'a' entspricht, sowie einem Case-Block vom Typ 'SELECT', in dem ein Aufruf der Funktion T enthalten ist. Übersetzung in "ιf(a){f(x,y);}"FIG. 51 shows both indirect and nested access to elements of a container with object names l c4 'The iterators'ι4' assigned to 'c4' are elements of container nesting 'c3' and 'c2' The iterators' ι3 'and 'ι2' are elements of structures that are contained in a container with object name 'd'. The iterator 'ιV is assigned to this container. Indirect and nested, read and write access to an element of 'c4' is translated into "c4 [c2 [c1 [ι1] .ι2] [c1 [ι1] ι3]]" Figure 52 shows a selective control structure with a pre- Condition that corresponds to the value of the object 'a', and a case block of the type 'SELECT', which contains a call of the function T. Translation into "ιf (a) {f (x, y);}"
Figur 53 zeigt eine repetitive Kontrollstruktur mit einem Prolog zur Initialisierung der Pre-Condition, die dem Wert des Objekts 'a' entspricht, sowie einem Case-Block vom Typ 'REPEAT, in dem ein Aufruf der Funktion 'g' enthalten ist. Übersetzung in "{x operator*(y);f(u, v);whιle(a){gO; }}" Figur 54 zeigt eine selektive Kontrollstruktur mit einer Pre-Condition, die dem Wert von 'a' entspricht, sowie mit Case-Blocken unterschiedlicher Post-Conditions Falls die Pre-Condition den Wert '1' annimmt, wird die Funktion 'f aufgerufen. Anderenfalls wird die Funktion 'g' aufgerufen. Übersetzung in "rf(a){f();}else{gO;}" Figur 55 zeigt eine selektive Kontrollstruktur mit einer Pre-Condition, die dem Wert von 'a' ent- spricht, sowie mit Case-Blocken, die sich im Vergleichsoperator ihrer Post-Conditions unterscheiden. Übersetzung in "ιf(a<0){f(),}else ιf(a==0){g();}else ιf(a>0){ h();}"FIG. 53 shows a repetitive control structure with a prologue for initializing the pre-condition, which corresponds to the value of the object 'a', and a case block of the type 'REPEAT, which contains a call to the function' g '. Translation into "{x operator * (y); f (u, v); whιle (a) {gO;}}" Figure 54 shows a selective control structure with a pre-condition that corresponds to the value of 'a' and with case blocks of different post-conditions If the pre-condition assumes the value '1', the function 'f is called. Otherwise the function 'g' is called. Translation into "rf (a) {f ();} else {gO;}" Figure 55 shows a selective control structure with a pre-condition that corresponds to the value of 'a' and with case blocks that are differentiate in the comparison operator of their post conditions. Translation into "ιf (a <0) {f (),} else ιf (a == 0) {g ();} else ιf (a> 0) {h ();}"
BERICHTIGTES BLATT (REGEL 91) ISA/EP Figur 56 zeigt eine gemischt selektive und repetitive Kontrollstruktur mit einer Pre-Condition, die dem Wert von 'a' entspricht, sowie mit zwei Case-Blocken vom Typ 'REPEAT', nach deren Ausführung ein Rücksprung auf die Pre-Condition erfolgt. Nach Ausführung des Case-Blockes vom Typ 'SELECT' wird die Kontrollstruktur verlassen. Übersetzung in "label:swιtch(a){case 5:f0; goto iabel;case 9:g( );break;default:hO;goto label,}".CORRECTED SHEET (RULE 91) ISA / EP FIG. 56 shows a mixed selective and repetitive control structure with a pre-condition that corresponds to the value of 'a' and with two case blocks of the 'REPEAT' type, after execution of which a return to the pre-condition takes place. After the execution of the 'SELECT' case block, the control structure is exited. Translation into "label: swιtch (a) {case 5: f0; goto iabel; case 9: g (); break; default: hO; goto label,}".
Figur 57 zeigt ein Objekt der Speicherklasse 'DYNAMIC mit Klassennamen 'dyn' und Objektnamen 'd', welches ein Objekt der Klasse 'typ' enthalt, sowie einen Iterator mit dem Klassennamen 'itr' und dem Objektnamen Y. Übersetzung in "dyn<typ> d;ιtr<typ> ι,". Die dynamische Spei- cherplatzzuweisung für ein Objekt der Klasse 'typ' erfolgt durch den Aufruf von 'neu', Ele- mentfunktion von 'd'. Das Ergebnis des Aufrufs ist ein Iteratorwert, der Y zugewiesen wird. Übersetzung in "ι=d.neu();" Die Speicherplatzfreigabe erfolgt durch Aufruf von 'loschen', Elementfunktion von 'd', mit Parameter Y. Übersetzung in "d.loschen(ι);".Figure 57 shows an object of the storage class' DYNAMIC with class name 'dyn' and object name 'd', which contains an object of the class' type ', and an iterator with the class name' itr 'and the object name Y. Translation into "dyn <type > d; ιtr <typ> ι, ". The dynamic storage space allocation for an object of the class 'type' is done by calling 'new', element function of 'd'. The result of the call is an iterator value that is assigned to Y. Translation into "ι = d.neu ();" The storage space is released by calling 'loschen', element function of 'd', with parameter Y. Translation into "d.loschen (ι);".
Figur 58 zeigt die Definition einer Funktion namens lunc' Im Datenteil befinden sich drei Objekte mit den Klassennamen 'A', 'B' bzw 'C, sowie den Objektnamen 'a', 'b' bzw. 'c' 'b' ist als Eingabeparameter gekennzeichnet, 'c' ist als Ein- und Ausgabeparameter gekennzeichnet und wird durch die Funktion verändert. Der Rücksprung erfolgt mithilfe des Terminators 'return'. Returnwert ist das Objekt 'ä Übersetzung in "A func(B& _b,C& c){B b(_b);A a, ... a=c+b;c~, ... return(a);}" Figur 59 zeigt die Definition einer Klasse namens 'X' Die Klasse enthalt drei Datenelemente mit den Klasseππamen 'A, 'B' bzw. 'C, und den Objektnamen 'a', 'b' bzw. 'c'. Übersetzung in "class X{A a;B b;C c;publιc: . f1 (...){...} ... f2(...){.. } ... f3(...){...}},"Figure 58 shows the definition of a function called lunc 'There are three objects in the data part with the class names' A ',' B 'or' C, and the object names 'a', 'b' or 'c' 'b' is as Input parameters marked, 'c' is marked as input and output parameters and is changed by the function. The return occurs with the terminator 'return'. The return value is the object 'ä Translation into "A func (B & _b, C & c) {B b (_b); A a, ... a = c + b; c ~, ... return (a);}" Figure 59 shows the definition of a class called 'X'. The class contains three data elements with the class names 'A,' B 'and' C, and the object names 'a', 'b' and 'c'. Translation into "class X {A a; B b; C c; publιc:. F1 (...) {...} ... f2 (...) {..} ... f3 (... ) {...}}, "
Figur 60 zeigt eine Klasse namens 'X' und eine von ihr abgeleitete Klasse namens Υ 'X' enthalt zwei Datenelemente mit den Klassennamen 'A' und 'B' sowie zwei Elementfunktionen mit Namen 11' und 12' 11 ' ist als virtuell deklariert 'Y' enthalt ein Datenelement mit dem Klasseπnamen 'C und dem Objektnamen 'c', sowie zwei Elementfunktionen mit Namen 11 ' und 12'. Υ:-f1' ist eine Redefinition der gleichnamigen Elementfunktion von 'X' Übersetzung in "class X {protected:A a;B b; pubiιc:vιrtual . f1 (...){...} . f2(.. ){ }};class Y.public X {C cpublic . f1 (.. ){. .} . f3(.. ){ ..}};" Figur 61 zeigt die Definition eines Containers namens 'cont' 'cont' enthalt ein Objekt der Speicherklasse 'DYNAMIC mit Klassennamen 'dyn' und Objektnamen 'd', welches ein Objekt der Klasse 'B' enthalt. Die Klassenbezeichnung 'B' ist als Parameter des Containers gekennzeichnet, 'd' ist für die dynamische Speicherplatzverwaltung ein Iterator der Klasse 'ttr* mit Objektnamen Y zugeordnet, 'cont' enthalt ein weiteres Datenelement namens 'a', dessen Klassenbezeichnung 'A' ebenfalls als Parameter von 'cont' gekennzeichnet ist 'cont' ist für die Traversierung ein Iterator zugeordnet mit Klassennamen 'rter' und Objektnamen 'ι1' Übersetzung in "template<class A, class B> class cont{dyn<B> d;ιtr<B> ι;A a, ... fπend . ιter<B> ι1 ( .),},"Figure 60 shows a class named 'X' and a class derived from it called 'X' contains two data elements with the class names 'A' and 'B' and two element functions with the names 11 'and 12' 11 'is declared as virtual' Y 'contains a data element with the class name' C and the object name 'c', as well as two element functions with names 11 'and 12'. Υ: -f1 'is a redefinition of the element function of the same name from' X 'Translation into "class X {protected: A a; B b; pubiιc: vιrtual. F1 (...) {...}. F2 (..) {}}; class Y.public X {C cpublic. f1 (..) {..}. f3 (..) {..}}; " Figure 61 shows the definition of a container called 'cont''cont' contains an object of the storage class' DYNAMIC with class name 'dyn' and object name 'd', which contains an object of class' B '. The class designation 'B' is identified as a parameter of the container, 'd' is assigned an iterator of class' ttr * with object name Y for dynamic storage space management, 'cont' contains another data element called 'a', whose class designation 'A' also is marked as a parameter of 'cont''cont' is assigned an iterator for traversing with class name 'rter' and object name 'ι1' translation into "template <class A, class B> class cont {dyn <B>d; ιtr <B>ι; A a, ... fπend. Ιter <B> ι1 (.),}, "
55.3 Speicher55.3 Memory
Die Aufgabe, das Speicherabbild eines visuellen Programms in einem nicht-flüchtigen Speicher aufzubewahren und von dort wieder zurück in den Arbeitsspeicher zu befördern, wird erfindungs- gemaß dadurch gelost, a) daß das Speicherabbild des visuellen Programms als zusammenhän-According to the invention, the task of storing the memory image of a visual program in a non-volatile memory and of transporting it back to the working memory is achieved in that a) the memory image of the visual program as a related
BERICHTIGTES BLATT (REGEL 91) ISA/EP gendes Objekt mit allen seinen internen Beziehungen vom Arbeitsspeicher in eine objekt-oreintier- te Datenbank verlagert wird, b) daß das Speicherabbild als zusammenhangendes Objekt mit allen seinen internen Beziehungen aus einer objekt-oπentierten Datenbank in den Arbeitsspeicher verlagert wird, und c) daß das Speicherabbild zur Unterstützung des Verfahrens nach a) und b) mit zusätzlichen Informationen angereichert wirdCORRECTED SHEET (RULE 91) ISA / EP object with all its internal relationships is shifted from the working memory to an object-oriented database, b) the memory image is moved as a coherent object with all its internal relationships from an object-oriented database to the working memory, and c) that Memory image to support the process according to a) and b) is enriched with additional information
Die Aufbewahrung des Speicherabbildes eines visuellen Programms nach dem hier beschriebenen Verfahren nutzt die Fähigkeit objekt-oπentierter oder objekt-relationaler Datenbanken aus, Objekte nicht nur mit ihren Attributen, sondern auch mit all ihren Beziehungen untereinander abzuspeichern, sodaß erstens jederzeit eine schnelle Wiederherstellung des Speicherabbilds im Arbeitsspeicher möglich ist und zweitens die Integration unterschiedlichster Entwicklungsdaten mit allen ihren internen Beziehungen langfristig erhalten bleibt Die objekt-oπentierte Datenbank ist damit zentraler Bestandteil der hier beschriebenen ProgrammierumgebungThe storage of the memory image of a visual program according to the method described here takes advantage of the ability of object-oriented or object-relational databases to store objects not only with their attributes, but also with all their relationships with one another, so that firstly, a quick restoration of the memory image in the Main memory is possible and secondly the integration of different development data with all their internal relationships is preserved in the long term. The object-oriented database is therefore a central component of the programming environment described here
Verschiedene Funktionen der Programmierumgebung können, ganz oder teilweise, unmittelbar durch Standardfunktionen einer objekt-oπentierten bzw objekt-relationalen Datenbank realisiert werden, so etwa die Versionsverwaltung, Aufgaben der Statistik und des Archivierens, Namensverwaltung (durch Invertier- und Suchfunktionen), Team-Arbeit (durch Zugriffssynchronisation, Locking- und Transaktionsmechanismen), Integration und Editieren mit versuchsweisem Einfugen (durch Roll-Back- und Integπtatsmechamsmen), sowie Navigation und Recherche (durch navigierende und assoziative Zugriffsmechanismen und Suchanfragen)Various functions of the programming environment can be implemented, in whole or in part, directly through standard functions of an object-oriented or object-relational database, such as version management, statistical and archiving tasks, name management (using inverting and search functions), teamwork ( through access synchronization, locking and transaction mechanisms), integration and editing with experimental insertion (through roll-back and integration mechanisms), as well as navigation and research (through navigating and associative access mechanisms and search queries)
Das Speicherabbild eines visuellen Programms kann ganz oder teilweise von bzw zu der Datenbank übertragen werden Die Selektion von Teilen des Speicherabbilds kann aufgrund topologi- scher Kriterien erfolgen wie etwa bei der Selektion eines Teilbaumes, oder aufgrund einer booleschen Suchanfrage, die auch eine topologisch nicht zusammenhangende Treffermenge ergeben kann Die selektierten Objekte können für eine Anzeige topologisch ergänzt und farblich weiter aufbereitet werden Um den selektiven Zugriff auf ein in der Datenbank befindliches Speicherabbild zu unterstutzen, können die Objekte, z B durch indexieren, mit zusätzlichen Informationen an- gereichert werdenThe memory map of a visual program can be transferred in whole or in part from or to the database. The selection of parts of the memory map can take place on the basis of topological criteria, such as when selecting a subtree, or on the basis of a Boolean search query which also contains a topologically non-contiguous set of hits The selected objects can be topologically supplemented for a display and further processed in color. To support the selective access to a memory image in the database, the objects can be enriched with additional information, eg by indexing
554 Graphische Wiederαaαbe554 Graphical Repeat
Die Aufgabe, das Speicherabbild eines visuellen Programms graphisch wiederzugeben, wird er- findungsmaßig dadurch gelost a) daß das Speicherabbild des visuellen Programms, ganz oder teilweise, in unterschiedlichen Hierarchiestufen Abstraktionsebenen, Detaillierungsgraden und Maßstaben wiedergegeben wird, b) daß Beziehungen und Abhängigkeiten zwischen Teilen des Speicherabbildes graphisch hervorgehoben werden, c) daß Verzweigungsebenen des Speicherabbildes drei-dimensional geschichtet und in perspektivischer Ansicht dargestellt werden, d) daß Teile der graphischen Wiedergabe des Speicherabbildes vorübergehend mit Teilen eines fremden Speicherabbildes graphisch überlagert werden und e) daß die Objekte des Speicherabbilds mit Informationen zur Unterstützung des Verfahrens nach a) bis d) angereichert werdenThe task of graphically reproducing the memory image of a visual program is solved according to the invention by a) the memory image of the visual program, in whole or in part, being reproduced in different hierarchical levels, levels of abstraction, levels of detail and scales, b) that relationships and dependencies between parts of the Memory image are highlighted graphically, c) that branching planes of the memory image are three-dimensionally layered and shown in perspective view, d) that parts of the graphic representation of the memory image are temporarily combined with parts of a foreign one Memory image are superimposed graphically and e) that the obj ects of the memory map with information in support of the method of a) to d) are enriched
Die graphische Wiedergabe eines visuellen Programms kann in Ubersichts- und Detailansichten erfolgen, die auf verschiedene Fenster einer graphischen Benutzeroberflache verteilt sein oder auf anderen graphischen Ausgabemedien dauerhaft ausgegeben werden können Diese Ansichten können durch Hilfsinformationen ergänzt sein, wie z B Orientierungsangaben, Beschriftungen und Dokumentation Die Wiedergabe kann selektiv erfolgen, indem einzelne Teile der Systemhierarchie hervorgehoben werden, indem Abstraktionen und Vergroberungen angewandt werden und indem auch durch Maßstabsanderungen Detail erungsgrad und Umfang der angezeigten Systemteile verändert werdenThe graphical representation of a visual program can take place in overview and detail views, which can be distributed over different windows of a graphical user interface or can be output permanently on other graphical output media.These views can be supplemented by auxiliary information, such as orientation information, labeling and documentation can be done selectively by highlighting individual parts of the system hierarchy, by applying abstractions and coarsening and by changing the level of detail and scope of the displayed system parts by changing the scale
Die graphische Wiedergabe visua siert die Beziehungen und Abhängigkeiten zwischen den visuellen Programmelementen durch farbliche Hervorhebung relevanter Teile oder Ausblenden nicht-re- levanter Teile Beispiele sind die Hierarchien für Aufruf und Benutzung von Funktionen, sowie die Verkettung von Funktionsaufrufen über Objekte und von Objekten über Funktionsaufrufe Ebenso können Ergebnismengen aus topologie- oder attributbezogenen Suchanfragen sichtbar gemacht werden Das Speicherabbild kann hierfür mit geeigneten Attributen angereichert werden Weitere Beziehungen ergeben sich aus Nachbarschaften bezüglich einer Entwurfsdimension, wie z B die Fehlerbehandlung, deren funktionale Elemente nach Anwendungs- und Systembezug sortiert und sichtbar gemacht werden könnenThe graphic representation visualizes the relationships and dependencies between the visual program elements by highlighting relevant parts or hiding non-relevant parts. Examples are the hierarchies for calling and using functions, as well as the chaining of function calls via objects and of objects via function calls result sets from topology or attribute-related search queries can be made visible. The memory image can be enriched for this with suitable attributes. Further relationships result from neighborhoods with regard to a design dimension, such as error handling, the functional elements of which can be sorted and made visible according to application and system reference
Die graphische Wiedergabe umfaßt auch die Visualisierung des Entwurfsprozesses Grundlage hierfür ist eine Zuordnung von Programmelementen zu Leistungsmerkmalen des Programms Hierzu muß das Speicherabbild um Attribute zur Kodierung von Leistungsmerkmalen und zur Aufnahme von Zeitmarken angereichert werden So kann wahrend des Editiervorgangs dem Programmierer laufend angezeigt werden, welches Leistungsmerkmal editiert wird und welche Programmelemente bisher dafür verwendet wurden Ebenso ist es möglich, das Speicherabbild gemäß der zeitlichen Abfolge des Eπtwurfsprozesses nach Leistuπgsmerkmalen durchzublättern Analog zum Entwurfsprozeß kann auch mit den verwendeten Entwurfsmustern verfahren werdenThe graphic representation also includes the visualization of the design process.The basis for this is an assignment of program elements to performance features of the program.For this purpose, the memory image must be enriched with attributes for coding performance features and for recording time stamps. During the editing process, the programmer can be continuously shown which performance feature is edited and which program elements have previously been used for this. It is also possible to scroll through the memory image according to the time sequence of the design process according to performance characteristics. The design patterns used can also be used analogously to the design process
Alle Verzweigungen des Speicherabbildes, die keine zeitliche Aufeinanderfolge beinhalten, können auch in Form einer drei-dimensionalen Schichtung von Funktionsebenen angeordnet und in perspektivischer Sicht wiedergegeben werden Dazu gehören die funktionalen Einheiten von SELECT- und REPEAT -Anweisungen (Cases), parallel auszuführende Anweisungen (Threads) und Anweisungsfolgen für den Fehlerfall (Exception Hand ng) Weitere sinnvolle Beispiele sind funktionale Einheiten ohne Kommunikation über globale Objekte so etwa SystemebenenAll branches of the memory image that do not contain a chronological sequence can also be arranged in the form of a three-dimensional layering of functional levels and reproduced in a perspective view.This includes the functional units of SELECT and REPEAT statements (cases), instructions to be executed in parallel (threads ) and instruction sequences in the event of an error (exception hand ng) Further useful examples are functional units without communication via global objects such as system levels
Für Clipboard-Operationen wahrend des Editierens, für die Integration größerer Systemteile, sowie für die Gegenüberstellung und den Vergleich von Systemkomponenten sollen Teile der graphischen Wiedergabe des Speicherabbildes vorübergehend mit Teilen eines fremden Speicher- abbildes graphisch überlagert werden können Dadurch können versuchsweise Einfuge- und Ersetzungsoperationen graphisch unterstutzt werden, Entwurfsalternativen gegenübergestellt, Entwurfsmuster oder wiederverwendbare Komponenten eingepaßt werdenFor clipboard operations during editing, for the integration of larger system parts, as well as for the comparison and comparison of system components, parts of the graphic representation of the memory image are to be temporarily compared with parts from an external memory. image can be graphically superimposed. This allows experimentally inserting and replacing operations to be graphically supported, design alternatives compared, design patterns or reusable components fitted
555 Dokumentation555 documentation
Die Aufgabe, das Speicherabbild eines visuellen Programms zu dokumentieren, wird erfindungsgemaß dadurch gelost, a) daß unmittelbar in dem auf einem Bildschirm angezeigten visuellen Programm mithilfe eines graphischen Eingabewerkzeugs Operationen zur Eingabe von Dokumenta- tionstexten, Kommentaren und andersartiger Information ausgelost werden können, b) daß in Abhängigkeit von der Eingabeposition innerhalb des visuellen Programms die eingegebene Dokumentation einzelnen Programmelementen zugeordnet wird, c) daß die einem Programmelement zugeordnete Dokumentation wahrend der Bearbeitung des Programms jederzeit lokal zur Verfugung steht, d) daß für jede funktionale Einheit die Dokumentation aller ihrer Programm- elemente jederzeit in geschlossener Form ausgegeben werden kann, und e) daß die Objekte des Speicherabbilds mit Attributen zur Unterstützung des Verfahrens nach a) bis d) angereichert werdenThe task of documenting the memory map of a visual program is achieved according to the invention in that a) operations for entering documentation texts, comments and other types of information can be triggered directly in the visual program displayed on a screen with the aid of a graphic input tool, b) that depending on the input position within the visual program, the documentation entered is assigned to individual program elements, c) that the documentation assigned to a program element is available locally at all times during the processing of the program, d) that the documentation of all its program units is available for each functional unit elements can be output in closed form at any time, and e) that the objects of the memory image are enriched with attributes to support the method according to a) to d)
Die Dokumentation eines visuellen Programms wird unmittelbar in das Programm selbst integriert und steht wahrend des Editierens oder bei graphischen Wiedergaben lokal zur Verfugung Die den einzelnen Programmelementen zugeordneten Dokumentationen können für jeden Teilbaum des Speicherabbilds zu einem Gesamtdokument extrahiert werden, das entsprechend der Baumstruktur des Speicherabbilds hierarchisch gegliedert ist Weiterhin kann es mit Ubersichts- oder Detaildarstellungen des visuellen Programms ergänzt werdenThe documentation of a visual program is integrated directly into the program itself and is available locally during editing or in the case of graphical reproductions. The documentation assigned to the individual program elements can be extracted into an overall document for each subtree of the memory image, which is hierarchically structured according to the tree structure of the memory image Furthermore, it can be supplemented with overview or detailed representations of the visual program
55 6 Verwaltung55 6 Administration
Die Aufgabe, das Speicherabbild eines visuellen Programms zu verwalten, wird erfindungsgemaß dadurch gelost, a) daß der Fertigstellungsgrad des visuellen Programms aus der attributiven und topologischen Vollständigkeit seines Speicherabbildes automatisch ermittelt wird, b) daß der Entstehungsgang des Speicherabbilds protokolliert wird und der zukunftige Projektverlauf aus dem bisherigen Entstehungsgang des Speicherabbilds automatisch ermittelt wird, c) daß die Verwal- tung von Namens- und Typ-Information von Operanden und Operationen durch Standardfunktio- nen einer objekt-relationalen Datenbank geleistet wird d) daß die Verwaltung von Versionen, Entwurfsalternativen und Entwurfsmustern durch Standardfunktionen einer objekt-relationalen Datenbank geleistet wird und e) daß die Objekte des Speicherabbildes mit Informationen zur Unterstützung des Verfahrens nach a) bis d) angereichert werden Der Projektstatus einer visuellen Programmentwicklung kann naherungsweise dem Zustand des Speicherabbildes entnommen werden Er entspricht in etwa der Vollständigkeit des Speicherabbildes Diese kann, attπbut- und topologiebezogen, aus dem bereits vorhandenen Speicherabbild extrapoliert werden Beispielsweise gehören zu einer Container-Spezifikation die Angabe von Klassen- und Instanznamen, die Spezifikation der Container-Elemente, ein Iterator, eine Zuordnung des Iterators zu dem Container, eine Spezifikation der Traverse und des Namens für den Iterator, Zugπffspfeile auf den Container, Kreuzungsmarken für Zugπffspfeile und Iterator, Zugriffe auf den Iterator, usw Aus der Zusammengehörigkeit der verschiedenen Spezifikationen kann durch Nachprüfen der Attribute und der Topologie des Speicherabbilds die Vollständigkeit ermittelt werden Diese laßt sich auch differenziert nach Ebenen, Klassen, Funktionen, Operanden, Operatoren, Typ- und Namensspezifikationen, Traversen für Container, Zugπffspfeile, Kreuzungsmarken und Dokumentation ermitteln Als Maßstab für die Vollständigkeit kann auch die Compi- herbarkeit gewählt werden Ebenso kann als Statusinformation auch eine attπbut- oder topo- logiebezogene Statistik ausgegeben werdenThe task of managing the memory map of a visual program is achieved according to the invention in that a) that the degree of completion of the visual program is automatically determined from the attributive and topological completeness of its memory map, b) that the development of the memory map is logged and the future course of the project the history of the creation of the memory map is determined automatically, c) that the administration of name and type information of operands and operations is carried out by standard functions of an object-relational database d) that the administration of versions, design alternatives and design patterns is carried out by Standard functions of an object-relational database are performed and e) that the objects of the memory image are enriched with information to support the method according to a) to d) The project status of a visual program development can be roughly derived from the state of the memory image. It roughly corresponds to the completeness of the memory image. This can be extrapolated, based on attributes and topology, from the existing memory image. For example, a container specification includes the specification of class and instance names , the specification of the container elements, an iterator, an assignment of the iterator to the container, a specification of the traverse and the name for the iterator, arrows on the container, crossing marks for arrows and iterator, accesses to the iterator, etc. From togetherness The completeness of the various specifications can be determined by checking the attributes and the topology of the memory image. This can also be differentiated according to levels, classes, functions, operands, operators, type and name specifications, traverses for containers Determine traction arrows, intersection marks and documentation. Compatibility can also be selected as a measure of completeness. Likewise, status or topology-related statistics can also be output as status information
Der Projektverlauf kann naherungsweise dem Entstehungsgang der Leistungsmerkmale des Speicherabbildes entnommen werden Dieser kann protokolliert werden durch Zuordnung von Zeit-, Personen- und Planungsdaten zu den funktionalen Einheiten des Speicherabbildes Hierfür ist das Speicherabbild mit entsprechenden Attributen anzureichern Der weitere Projektverlauf kann aus dem Projektstatus und dem bisherigen Projektverlauf extrapoliert werden Die Genauigkeit der automatischen Schätzungen von Projektstatus und Projektverlauf nimmt mit zunehmender Vollständigkeit des Speicherabbildes zuThe course of the project can be roughly taken from the development of the performance characteristics of the memory image.This can be logged by assigning time, person and planning data to the functional units of the memory image. The memory image must be enriched with the appropriate attributes Project history are extrapolated The accuracy of the automatic estimates of project status and project history increases with increasing completeness of the memory map
Die verfugbaren, selbstdefinierten oder importierten, Funktionen, Datenstrukturen Klassen und Entwurfsmuster werden gemeinsam verwaltet Ihre Namens-, Typ- und Struktur-Information kann in Übersichten angezeigt und direkt in Arbeitsgange wie Editieren oder Dokumentieren eingeführt werden Diese Informationen können nach verschiedenen Kriterien invertiert und sortiert werden Dafür kann eine relationale Erweiterung einer objekt-oπentierten Datenbank mit ihren Standardfunktionen verwendet werdenThe available, self-defined or imported functions, data structures, classes and design patterns are managed together. Your name, type and structure information can be displayed in overviews and directly introduced into work processes such as editing or documenting. This information can be inverted and sorted according to various criteria A relational extension of an object-oriented database with its standard functions can be used for this
Die Aufgaben der Versionsverwaltung können ebenfalls durch die Standardfunktionen der Datenbank unterstützt werden Analog dazu kann auch die Verwaltung von Entwurfsalternativen und Entwurfsmustern erfolgenThe version management tasks can also be supported by the standard functions of the database. Analogously, the design alternatives and designs can also be managed
55 7 Navigation55 7 Navigation
Die Aufgabe, in der graphischen Wiedergabe des Speicherabbildes eines visuellen Programms zu navigieren, wird erfindungsgemaß dadurch gelost, a) daß die Anzeige der Objekte des Soeicher- abbilds des visuellen Programms in topologischen und assoziativen Traversen verlauft, b) daß die Anzeige der Objekte des Speicherabbilds zwischen verschiedenen Abstraktionsebenen, Detail e- rungsgraden und Maßstaben wechselt, c) daß eine perspektivische Anzeige drei-dimensional an- geordneter Objekte des Speicherabbilds durch allmähliche Richtungsanderung, Annäherung und Entfernung erfolgt, d) daß Hilfsinformation zur Orientierung, Dokumentation und Verwaltung angezeigt wird und e) daß die Objekte des Speicherabbilds mit Informationen zur Unterstützung des Verfahrens nach a) bis d) angereichert werdenThe task of navigating in the graphical representation of the memory image of a visual program is achieved according to the invention in that a) the display of the objects of the Soeicher image of the visual program proceeds in topological and associative trusses, b) that the display of the objects of the memory image changes between different levels of abstraction, levels of detail and scales, c) that a perspective display is three-dimensional orderly objects of the memory image by gradual change of direction, approach and distance, d) that auxiliary information for orientation, documentation and management is displayed and e) that the objects of the memory image are enriched with information to support the method according to a) to d)
Die Betrachtung eines visuellen Programms soll nicht nur am stehenden Bild erfolgen, sondern auch mittels einer scheinbaren Bewegung des Betrachters durch das Speicherabbild, die seinen Entwurfsuberlegungen oder diversen Funktionszusammenhangen folgt Die Betrachtung kann in perspektivischer Sicht auf die funktionalen Einheiten geschehen, insbesondere auf drei-dimensio- nal angeordnete Verzweigungsebenen wie z B für Cases, Threads und Exceptions Die Bewegung kann in unterschiedlichen, kontinuierlichen Tempi erfolgen, mit Schwenks in der Blickrichtung, Annäherungen an Details und Entfernungen Betrachtung und Bewegung können durch Wechsel der Perspektive, der Abstraktionsebene, des Detaillierungsgrades und der Position auch sprunghaft verändert werden Sie können einerseits der Baumstruktur des Speicherabbilds folgen, andererseits funktionalen Zusammenhangen, wie Kontrollfluß, Aufruf- und Benutzungshierarchien oder die Treffermenge einer Suchanfrage traversieren Durch graphische und textuelle Hilfsinformation kann der Betrachter bei seiner Orientierung im System unterstutzt werdenThe viewing of a visual program should not only take place on the standing image, but also by means of an apparent movement of the viewer through the memory image, which follows his design considerations or various functional contexts. The viewing can be done in a perspective view of the functional units, especially in three dimensions. nally arranged branching levels such as for cases, threads and exceptions The movement can take place in different, continuous tempos, with panning in the direction of view, approximations to details and distances. Viewing and movement can be done by changing the perspective, the level of abstraction, the level of detail and the position can also be changed by leaps and bounds. You can follow the tree structure of the memory map on the one hand, and on the other hand functional contexts such as control flow, call and usage hierarchies or the number of hits of a search query can be traversed by graphic and Textual auxiliary information can be used to help the viewer find his way around the system
558 Animation558 animation
Die Aufgabe, die graphische Wiedergabe des Speicherabbilds eines visuellen Programms zu animieren, wird erfindungsgemaß dadurch gelost, daß Funktionsablaufe, Zusammenhange und Abhängigkeiten innerhalb des visuellen Programms durch aufeinanderfolgende farbliche oder akustische Kennzeichnung hervorgehoben werdenThe task of animating the graphical representation of the memory map of a visual program is achieved according to the invention in that functional sequences, relationships and dependencies within the visual program are highlighted by successive color or acoustic identification
In der graphischen Wiedergabe eines visuellen Programms kann durch aufeinanderfolgende farbliche Kennzeichnung beispielsweise der Kontrollfluß deutlich gemacht werden Dabei können in jedem Ablaufschπtt alle beteiligten Funktionen, Operationen, Zugπffspfeile und Objekte farblich hervorgehoben werden Die Animation des Kontrollflusses kann mit oder ohne Ergänzung durch Laufzeitwerte erfolgen Im ersten Fall können den Objekten des Speicherabbilds beim Ablauf des visuellen Programms durch besonders generierte Anweisungen Werte zugewiesen werden, die in einer anschließenden Animation abgespielt werden können Diese Anweisungen können optional bei der Übersetzung des Speicherabbilds in den Quellcode eingestreut werden Die Animation wird dabei durch den Datenfall bestimmt und lauft automatisch ab, wobei Laufzeitfehler an ihrem Entstehungsort angezeigt werden Im zweiten Fall wird der Kontrollfluß durch Anklicken von Cases manuell gesteuertIn the graphical representation of a visual program, the control flow can be made clear, for example, by means of successive color coding. All the functions, operations, arrows and objects involved can be highlighted in each sequence. The control flow can be animated with or without the addition of runtime values. In the first case Values can be assigned to the objects of the memory image when the visual program is running using specially generated instructions, which can be played in a subsequent animation.These instructions can optionally be interspersed with the translation of the memory image into the source code.The animation is determined and run by the data case automatically, whereby runtime errors are displayed at their point of origin. In the second case, the control flow is controlled manually by clicking Cases
Die an einem Programmdurchlauf beteiligten Funktionen, Operationen, Zugrrffspfeile und Objekte können auch simultan angezeigt werden Damit können die aktiven Bereiche eines Programms sichtbar gemacht werden Dies kann wieder abhangig von einem konkreten Datenfall geschehen oder manuell gesteuert durch Ankhcken von Cases Durch wechselnde Anzeige verschiedener Bereiche kann die Auswirkung verschiedener Datenfalle gegenübergestellt werden Weitere Beispiele für eine simultane Anzeige von Programmelementen sind die Aufruf- und Benutzungshierarchien Auch Treffermengen zu unterschiedlichen Suchanfragen können so in wechselnder Abfolge einander gegenübergestellt werdenThe functions, operations, access arrows and objects involved in a program run can also be displayed simultaneously.This enables the active areas of a program to be made visible.This can be done depending on a specific data case or manually controlled by checking cases by changing the display of different ones The impact of different data traps can be compared to other areas. The call and usage hierarchies are further examples of a simultaneous display of program elements. Also, sets of hits for different search queries can be compared in an alternating sequence
6. Ausführungsform6th embodiment
Das erfindungsgemaße Verfahren erlaubt, in Anlehnung an den Entwurf integrierter Schaltkreise, die Anwendung von CAD-Methoden auf den Programmentwurf. Insbesondere ist nicht das lauf- fähige Programm, noch dessen Quellcode, das eigentliche Endprodukt des Verfahrens, sondern dessen visuelle Spezifikation Aus ihr kann der Quellcode bei Bedarf automatisch generiert werden Die Arbeitsgrundlage des Ingenieurs ist jedoch in jeder Phase des Programmlebenszyklus die visuelle Spezifikation nach dem hier beschriebenen Verfahren Aus ihr können verschiedene graphische Darstellungen generiert werden, durch die der Ingenieur, seinen Entwurfs- oder sonsti- gen Überlegungen entsprechend, navigieren kann, die er animieren und bearbeiten kann Die Bearbeitung wird, koπtext-abhangig, durch den hier beschriebenen Editor gefuhrt und so weitestgeh- end gegen Fehler abgesichert Das Speicherabbild der visuellen Spezifikation wird langfristig mit allen seinen internen Bezügen und Zusatzinformationen in einer objekt-oπentierten Datenbank abgelegt und ist einer Vielzahl unterschiedlichster Recherchen zugänglich, deren Ergebnisse wiederum graphisch dargestellt werden können Teamarbeit am Programm wird teils durch Funktionen der Datenbank, teils durch CAD-Funktionen zur Arbeitsorganisation unterstutztThe method according to the invention allows, based on the design of integrated circuits, the application of CAD methods to the program design. In particular, it is not the executable program, nor its source code, that is the actual end product of the process, but rather its visual specification. From it, the source code can be generated automatically if necessary. The working basis of the engineer is, however, the visual specification according to the here in every phase of the program life cycle The described method can be used to generate various graphical representations through which the engineer, according to his design or other considerations, can navigate, which he can animate and edit. Depending on the context, the editing is carried out by the editor described here and as far as possible protected against errors The long-term image of the visual specification with all its internal references and additional information is stored in an object-oriented database and is accessible to a wide variety of different searches, the results of which in turn are shown graphically Teamwork on the program is supported partly by functions of the database, partly by CAD functions for work organization
7. Vorteile7. Advantages
Gegenüber der textuellen Programmierung besitzt das angegebene Verfahren im Wesentlichen folgende Vorteile (1) Dadurch daß Abhängigkeiten zwischen den Programmelementen sichtbar sind, wird ein visuelles Programm verständlicher Unbeabsichtigte Abhängigkeiten werden weitgehend verhindert (2) Durch die Möglichkeit der Abstraktion und Vergroberung und durch schnelle Wechsel zwischen Ubersichts- und Detailansichten wird ein visuelles Programmsystem durchschaubarer (3) Durch die Benutzerfuhrung des visuellen Editors wird der Entwurf schneller und fehlersicherer (4) Der Übergang zwischen Spezifikation und Implementierung ist fließend, ebenso die Übergänge zwischen den Phasen des Programmlebenszyklus, für die das in der objekt-oπentierten Datenbank egende Speicherabbild eine konsistente Grundlage liefert Gegenüber anderen bekannten visuellen Programmierverfahreπ besitzt das angegebene Verfahren den Vorteil, daß es die imperative, d h auf Zuweisungen basierende, Programmierung unterstutzt Da es außerdem objekt-oπentiert und allgemein ist kann es als unmittelbare Visualisierung der in der Praxis derzeit gebräuchlichsten Programmiersprache, nämlich C++, verwendet werden Compared to textual programming, the specified method has the following main advantages (1) The fact that dependencies between the program elements are visible makes a visual program more understandable. Unintentional dependencies are largely prevented (2) Through the possibility of abstraction and coarsening and through a quick change between overview - and detailed views, a visual program system becomes more transparent (3) the user guidance of the visual editor makes the design faster and more reliable (4) the transition between specification and implementation is fluid, as are the transitions between the phases of the program life cycle, for which the in the object The oriented memory map provides a consistent basis. Compared to other known visual programming methods, the specified method has the advantage that it is imperative, ie based on assignments, programming and terstutzen Since it is also object-oriented and general, it can be used as an immediate visualization of the most common programming language currently used, namely C ++

Claims

8. Patentansprüche 8. Claims
1. Verfahren zur visuellen Programmierung eines Computers, dadurch gekennzeichnet, a) daß die Operationen, bestehend aus einfachen und ineinander verschachtelten Funktions- und Operationsaufrufen mit ihren Argumenten, gemäß ihren Nachbarschafts- und Inklusionsbeziehungen zueinander, durch eine erste Baumstruktur visualisiert werden, b) daß die Operanden, bestehend aus einfachen und ineinander verschachtelten Objekten und Datenstrukturen, gemäß ihren Nachbarschafts- und Inklusionsbeziehungen zueinander, durch eine zweite Baumstruktur visualisiert werden, und c) daß die Beziehungen zwischen den Operationen einerseits und den Operanden andererseits, bestehend aus Argument-, Zuweisungs-, Element- und anderen Beziehungen, durch Linienverbindungen zwischen Elementen der ersten Baumstruktur und Elementen der zweiten Baumstruktur visualisiert werden.1. A method for the visual programming of a computer, characterized in that a) that the operations, consisting of simple and nested function and operation calls with their arguments, are visualized by a first tree structure according to their neighborhood and inclusion relationships, b) that the operands, consisting of simple and nested objects and data structures, are visualized according to their neighborhood and inclusion relationships to one another by a second tree structure, and c) that the relationships between the operations on the one hand and the operands on the other hand, consisting of arguments, assignments , Element and other relationships can be visualized by line connections between elements of the first tree structure and elements of the second tree structure.
2. Verfahren nach Anspruch 1 , dadurch gekennzeichnet, daß ein Operand durch ein Baumele- ment visualisiert wird, das mit einem Klassen- und einem Objektnamen beschriftet ist.2. The method according to claim 1, characterized in that an operand is visualized by a tree element which is labeled with a class and an object name.
3. Verfahren nach Anspruch 1 und 2, dadurch gekennzeichnet, daß ein aus einer festen Anzahl unterschiedlicher Operanden zusammengesetzter Operand durch ein Baumelement visualisiert wird, das mit einem Klassen- und einem Objektnamen beschriftet ist und dem die feste Anzahl von Baumelementen folgt, welche seine unterschiedlichen Elemente repräsentieren. 3. The method according to claim 1 and 2, characterized in that an operand composed of a fixed number of different operands is visualized by a tree element, which is labeled with a class and an object name and which follows the fixed number of tree elements, which its different Represent elements.
4. Verfahren nach Anspruch 1 bis 3, dadurch gekennzeichnet, daß ein aus einer variablen Anzahl gleichartiger Operanden zusammengesetzter Operand durch ein Baumelement visualisiert wird, das mit einem Klassen- und einem Objektnamen beschriftet sein kann und dem ein Baumelement folgt, welches stellvertretend seine gleichartigen Elemente repräsentiert.4. The method according to claim 1 to 3, characterized in that an operand composed of a variable number of similar operands is visualized by a tree element which can be labeled with a class and an object name and which is followed by a tree element which represents its similar elements represents.
5. Verfahren nach Anspruch 1 bis 4, dadurch gekennzeichnet, daß ein Hilfs-Operand für die Tra- versierung eines aus einer variablen Anzahl gleichartiger Operanden zusammengesetzten Operanden durch ein Baumelement visualisiert wird, welches die aktuelle Position der Traverse und den Algorithmus zur Veränderung der Position repräsentiert und welches mit einem Traversen- und einem Objektnamen beschriftet ist.5. The method according to claim 1 to 4, characterized in that an auxiliary operand for traversing an operand composed of a variable number of similar operands is visualized by a tree element which shows the current position of the traverse and the algorithm for changing the position represents and which is labeled with a truss and an object name.
6. Verfahren nach Anspruch 1 bis 5, dadurch gekennzeichnet, daß eine Linienverbindung, die auf oder in dem stellvertretenden Operanden eines aus einer variablen Anzahl gleichartiger Operanden zusammengesetzten Operanden endet, zuvor über Baumelemente geführt wird, welche HilfsOperanden für die Traversierung repräsentieren.6. The method according to claim 1 to 5, characterized in that a line connection, which ends on or in the representative operand of an operand composed of a variable number of similar operands, is previously carried out via tree elements which represent auxiliary operands for traversing.
7. Verfahren nach Anspruch 1 bis 6, dadurch gekennzeichnet, daß eine Linienverbindung, die über einen Hilfs-Operanden für die Traversierung geführt wird, der selbst wieder stellvertretender Ope- rand eines aus einer variablen Anzahl gleichartiger Operanden zusammengesetzten Operanden ist oder in dem stellvertretenden Operanden enthalten ist, zuvor ebenfalls über Baumelemente geführt wird, welche Hilfs-Operanden für die Traversierung repräsentieren.7. The method according to claim 1 to 6, characterized in that a line connection, which is guided via an auxiliary operand for traversing, which is itself the representative operand of an operand composed of a variable number of similar operands or in the representative operand is also previously passed over tree elements which represent auxiliary operands for traversal.
8. Verfahren nach Anspruch 1 bis 7, dadurch gekennzeichnet, daß ein Operand mit dynamischer Speicherplatzzuteilung durch ein Baumelement visualisiert wird, das den stellvertretenden Ope- randen eines aus einer variablen Anzahl gleichartiger Operanden zusammengesetzten, besonders gekennzeichneten Operanden repräsentiert, wobei die Speicherposition des dynamisch zugeteilten Operanden durch ein weiteres Baumelement visualisiert wird, das- einen Hilfs-Operanden für die Traversierung repräsentiert.8. The method according to claim 1 to 7, characterized in that an operand with dynamic memory allocation is visualized by a tree element, the representative operand of a composed of a variable number of similar operands, especially represented operands, the storage position of the dynamically allocated operand being visualized by a further tree element which represents an auxiliary operand for traversing.
9. Verfahren nach Anspruch 1 bis 7, dadurch gekennzeichnet, daß ein Operand mit statischer Speicherplatzzuteilung durch ein Baumelement visualisiert wird, das den Operanden eines aus einer festen Anzahl unterschiedlicher Operanden zusammengesetzten, besonders gekennzeichneten Operanden repräsentiert.9. The method according to claim 1 to 7, characterized in that an operand with static memory allocation is visualized by a tree element, which represents the operand of a composed of a fixed number of different operands, specially marked operands.
10. Verfahren nach Anspruch 1 bis 7, dadurch gekennzeichnet, daß ein verteiltes Objekt durch ein Baumelement visualisiert wird, das den Operanden eines aus einer festen Anzahl unterschiedli- eher Operanden zusammengesetzten, besonders gekennzeichneten Operanden repräsentiert.10. The method according to claim 1 to 7, characterized in that a distributed object is visualized by a tree element, which represents the operand of an operand composed of a fixed number of different operands, specially marked operands.
11. Verfahren nach Anspruch 1 bis 10, dadurch gekennzeichnet, daß ein Baumelement, welches einen Operanden visualisiert, durch eine Hilfs-Linie verlängert werden kann, so daß Linien, die Beziehungen zu dem Baumelement visualisieren, auf dieser Hilfslinie enden können, und daß Linien, die über das Baumelement zu führen sind, diese Hilfslinie schneiden können, wobei der Schnittpunkt markiert wird.11. The method according to claim 1 to 10, characterized in that a tree element, which visualizes an operand, can be extended by an auxiliary line, so that lines that visualize relationships to the tree element can end on this auxiliary line, and that lines that are to be passed over the tree element can intersect this auxiliary line, the intersection being marked.
12. Verfahren nach Anspruch 1 bis 11 , dadurch gekennzeichnet, daß eine Linie, die über ein Baumelement geführt wird, das einen Hilfs-Operanden für die Traversierung repräsentiert, an ihrem Schnittpunkt mit diesem Baumelement mit einer eindeutigen Kennzeichnung des ihm zugeordneten zusammengesetzten Operanden beschriftet ist. 12. The method according to claim 1 to 11, characterized in that a line which is guided over a tree element, which represents an auxiliary operand for traversing, is labeled at its intersection with this tree element with a unique identifier of the composite operand assigned to it .
13. Verfahren nach Anspruch 1 bis 12, dadurch gekennzeichnet, daß bei einer Linie, die auf einem Operanden endet, durch weitere Kennzeichnung unterschieden wird, ob dieser Operand verändert wird oder nicht.13. The method according to claim 1 to 12, characterized in that in the case of a line which ends on an operand, a further distinction is made as to whether this operand is changed or not.
14. Verfahren nach Anspruch 1 bis 13, dadurch gekennzeichnet, daß bei einer Linie, die auf einem Operanden endet, durch weitere Kennzeichnung unterschieden wird, ob sie eine Argument-, Zuweisungs-, Element- oder andere Beziehung repräsentiert.14. The method according to claim 1 to 13, characterized in that a line that ends on an operand is distinguished by further identification, whether it represents an argument, assignment, element or other relationship.
15. Verfahren nach Anspruch 1 bis 14, dadurch gekennzeichnet, daß eine Operation durch ein Baumelement visualisiert wird, welches gleichzeitig den Aufruf und den Ergebniswert der Operation repräsentiert und das mit dem Operationsnamen oder -symbol beschriftet ist.15. The method according to claim 1 to 14, characterized in that an operation is visualized by a tree element which simultaneously represents the call and the result value of the operation and which is labeled with the operation name or symbol.
16. Verfahren nach Anspruch 1 bis 15, dadurch gekennzeichnet, daß ein Argument einer Opera- tion durch ein Baumelement visualisiert wird, welches dem Baumelement folgt, das die Operation repräsentiert.16. The method according to claim 1 to 15, characterized in that an argument of an operation is visualized by a tree element which follows the tree element which represents the operation.
17. Verfahren nach Anspruch 1 bis 16, dadurch gekennzeichnet, daß ein Baumelement, welches ein Argument einer Operation repräsentiert, mit dem Wert oder dem Namen einer Konstanten beschriftet ist und damit diese Konstante repräsentiert. 17. The method according to claim 1 to 16, characterized in that a tree element, which represents an argument of an operation, is labeled with the value or the name of a constant and thus represents this constant.
18. Verfahren nach Anspruch 1 bis 16, dadurch gekennzeichnet, daß ein Baumelement, welches ein Argument einer Operation repräsentiert, mit dem Baumelement eines Operanden über eine Linie verbunden ist und damit diesen Operanden repräsentiert.18. The method according to claim 1 to 16, characterized in that a tree element, which represents an argument of an operation, is connected to the tree element of an operand via a line and thus represents this operand.
19. Verfahren nach Anspruch 1 bis 16, dadurch gekennzeichnet, daß ein Baumeiement, welches ein Argument einer Operation repräsentiert, selbst wieder eine Operation repräsentiert. 19. The method according to claim 1 to 16, characterized in that a construction element, which represents an argument of an operation, itself represents an operation again.
20. Verfahren nach Anspruch 1 bis 19, dadurch gekennzeichnet, daß die unbedingte und sequentielle Ausführung einer Folge von Operationen durch ein Baumelement visualisiert wird, dem in derselben Reihenfolge die Baumelemente folgen, welche die Operationen repräsentieren.20. The method according to claim 1 to 19, characterized in that the unconditional and sequential execution of a sequence of operations is visualized by a tree element, which are followed in the same order by the tree elements which represent the operations.
21. Verfahren nach Anspruch 1 bis 20, dadurch gekennzeichnet, daß die selektive und sequentiel- le Ausführung einer Folge von Operationen durch ein besonders gekennzeichnetes Baumelement visualisiert wird, dem in derselben Reihenfolge die Baumelemente der Operationen folgen und das mit dem Symbol eines Vergleichsoperators, gefolgt von einer Konstanten, beschriftet ist.21. The method according to claim 1 to 20, characterized in that the selective and sequential execution of a sequence of operations is visualized by a specially marked tree element, followed by the tree elements of the operations in the same order and followed by the symbol of a comparison operator from a constant that is labeled.
22. Verfahren nach Anspruch 1 bis 21 , dadurch gekennzeichnet, daß die iterative und sequentielle Ausführung einer Folge von Operationen durch ein besonders gekennzeichnetes Baumelement visualisiert wird, dem in derselben Reihenfolge die Baumelemente der Operationen folgen und das mit dem Symbol eines Vergleichsoperators, gefolgt von einer Konstanten, beschriftet ist.22. The method according to claim 1 to 21, characterized in that the iterative and sequential execution of a sequence of operations is visualized by a specially marked tree element, followed by the tree elements of the operations in the same order and with the symbol of a comparison operator, followed by a Constants, is labeled.
23. Verfahren nach Anspruch 1 bis 22, dadurch gekennzeichnet, daß die kontrollierte Ausführung von Folgen von Operationen durch ein Baumelement visualisiert wird, welchem zunächst ein Baumelement folgt, das eine Folge von unbedingt auszuführenden Operationen repräsentiert und welchem sodann ein oder mehrere Baumelemente folgen, die jeweils eine selektiv oder iterativ auszuführende Folge von Operationen repräsentieren und deren Beschriftungen jeweils zusammen mit der Beschriftung der letzten unbedingt auszuführenden Operation die Selektions- und Iterationsbedingungen repräsentieren.23. The method according to claim 1 to 22, characterized in that the controlled execution of sequences of operations is visualized by a tree element, which is first followed by a tree element which represents a sequence of operations to be carried out and which is then followed by one or more tree elements which each represent a sequence of operations to be carried out selectively or iteratively and the labels of which, together with the label of the last operation to be absolutely carried out, represent the selection and iteration conditions.
24. Verfahren nach Anspruch 1 bis 23, dadurch gekennzeichnet, daß die parallele Ausführung von Folgen von Operationen durch ein Baumelement visualisiert wird, dem mehrere Baumelemente folgen, welche die parallel auszuführenden Folgen von Operationen repräsentieren.24. The method according to claim 1 to 23, characterized in that the parallel execution of sequences of operations is visualized by a tree element which is followed by several tree elements which represent the sequences of operations to be carried out in parallel.
25. Verfahren nach Anspruch 1 bis 24, dadurch gekennzeichnet, daß die Ausnahmebehandlung für eine sequentiell ausgeführte Folge von Operationen durch ein Baumelement visualisiert wird, dem zunächst das Baumelement folgt, welches die sequentiell ausgeführte Folge von Operationen repräsentiert und dem sodann weitere Baumelemente folgen, welche die Operationenfolgen der Ausnahmebehandlung repräsentieren.25. The method according to claim 1 to 24, characterized in that the exception handling for a sequentially executed sequence of operations is visualized by a tree element, which is first followed by the tree element which represents the sequentially executed sequence of operations and which are then followed by further tree elements which represent the sequences of operations of exception handling.
26. Verfahren nach Anspruch 1 bis 25, dadurch gekennzeichnet, daß eine aus Operationen und Operanden zusammengesetzte Funktionale Einheit durch ein Baumelement visualisiert wird, dem zunächst ein Baumelement folgt, welches eine Folge von Operationen repräsentiert und dem so- dann ein Baumelement folgt, welches die Folge der Operanden repräsentiert.26. The method according to claim 1 to 25, characterized in that a functional unit composed of operations and operands is visualized by a tree element, which is first followed by a tree element which represents a sequence of operations and then followed by a tree element which the Sequence of operands represented.
27. Verfahren nach Anspruch 1 bis 26, dadurch gekennzeichnet, daß in der Folge von Operationen einer Funktionalen Einheit auch selbst wieder Funktionale Einheiten vorkommen.27. The method according to claim 1 to 26, characterized in that in the sequence of operations of a functional unit itself functional units occur again.
28. Verfahren nach Anspruch 1 bis 27, dadurch gekennzeichnet, daß Programmblöcke unterschiedlicher Hierarchiestufe, Kontrollstrukturen, Funktions- und Operationsdefinitionen, Definitio- nen von Klassen und Unterklassen, Module unterschiedlicher Hierarchiestufe, logische, physische, administrative und andere Komponenten, Systemebenen und Systeme jeweils durch ein Baumelement visualisiert werden, das eine Funktionale Einheit repräsentiert.28. The method according to claim 1 to 27, characterized in that program blocks of different hierarchy levels, control structures, function and operation definitions, definitions of classes and subclasses, modules of different hierarchy levels, logical, physical, administrative and other components, system levels and systems a tree element can be visualized that represents a functional unit.
29. Verfahren nach Anspruch 1 bis 28, dadurch gekennzeichnet, daß die Operanden einer Funktionalen Einheit, welche eine Funktions- oder Operationsdefinition repräsentiert, durch besondere Kennzeichnung als Eingabe-, Ausgabe- oder Ein-Ausgabe-Parameter kenntlich gemacht werden und die Beendigung der Funktion oder Operation mit Rückgabe eines Ergebniswertes durch besondere Kennzeichnung einer oder mehrerer Operationen kenntlich gemacht wird.29. The method according to claim 1 to 28, characterized in that the operands of a functional unit, which represents a function or operation definition, are identified by special identification as input, output or input-output parameters and the termination of the function or operation is indicated by return of a result value by special identification of one or more operations.
30. Verfahren nach Anspruch 1 bis 29, dadurch gekennzeichnet, daß eine Klassendefinition durch ein Baumelement visualisiert wird, welches eine aus Funktionalen Einheiten und Operanden zu- sammengesetzte höhere Funktionale Einheit repräsentiert, wobei die Funktionalen Einheiten die Elementfunktionen der Klasse und die Operanden die Datenelemente der Klasse repräsentieren und das Baumelement mit dem Klassennamen, sowie mit den Namen von Konfigurationsparametern beschriftet ist.30. The method according to claim 1 to 29, characterized in that a class definition is visualized by a tree element which represents a higher functional unit composed of functional units and operands, the functional units the element functions of the class and the operands the data elements of the Represent class and the tree element is labeled with the class name and the names of configuration parameters.
31. Verfahren nach Anspruch 1 bis 30, dadurch gekennzeichnet, daß eine aus einer übergeordne- ten Klassendefinition (Oberklasse) abgeleitete Klassendefinition (Unterklasse) durch ein Baumelement visualisiert wird, welches eine aus Funktionalen Einheiten und Operanden zusammengesetzte höhere Funktionale Einheit repräsentiert und welches enthalten ist in der Folge der Baumelemente, die die Funktionalen Einheiten und Operationen repräsentieren, aus denen die übergeordnete höhere Funktionale Einheit zusammengesetzt ist, welche die übergeordnete Klassendefi- nition (Oberklasse) repräsentiert.31. The method according to claim 1 to 30, characterized in that a class definition (subclass) derived from a superordinate class definition (superclass) is visualized by a tree element which represents a higher functional unit composed of functional units and operands and which is contained in the sequence of the tree elements that represent the functional units and operations from which the higher, higher functional unit is composed, which represents the higher class definition (superclass).
32. Verfahren nach Anspruch 1 bis 31 , dadurch gekennzeichnet, daß die Abstraktion und die Vergröberung einer aus Funktionalen Einheiten, Operationen und Operanden zusammengesetzten höheren Funktionalen Einheit durch Weglassen dieser Funktionalen Einheiten, Operationen und Operanden visualisiert wird, wobei Zugriffspfeile auf dem Baumelement enden, das die höhere Funktionale Einheit repräsentiert.32. The method according to claim 1 to 31, characterized in that the abstraction and coarsening of a higher functional unit composed of functional units, operations and operands is visualized by omitting these functional units, operations and operands, with access arrows ending on the tree element, the represents the higher functional unit.
33. Verfahren nach Anspruch 1 bis 32, dadurch gekennzeichnet, daß jedem visuellen Programm ein Speicherabbild zugeordnet ist, bei dem die visuellen Programmbausteine durch Speicherobjekte und die visualisierten Beziehungen zwischen den Programmbausteinen durch Verweise zwischen den Speicherobjekten repräsentiert sind.33. The method according to claim 1 to 32, characterized in that each visual program is assigned a memory map in which the visual program blocks are represented by memory objects and the visualized relationships between the program blocks are represented by references between the memory objects.
34. Verfahren zur visuellen Programmierung eines Computers nach Anspruch 1 bis 33, dadurch gekennzeichnet, a) daß unmittelbar in dem auf einem Ausgabemedium angezeigten visuellen Programm mithilfe eines graphischen Eingabewerkzeugs Einfüge-, Änderungs- und Löschoperationen ausgelöst werden können, b) daß in Abhängigkeit von der Einfüge-, Änderungs- und Löschpo- sition innerhalb des visuellen Programms die Menge der möglichen Aktionen und Eingaben sinnvoll eingeschränkt und dies dem Programmierer angezeigt wird, c) daß in Abhängigkeit von der Einfüge-, Änderungs- und Löschposition innerhalb des visuellen Programms dem Programmierer zusätzliche Hilfsinformationen angezeigt werden und d) daß die Objekte des Speicherabbildes des visuellen Programms mit Informationen zur Unterstützung des Verfahrens nach a) bis c) ange- reichert werden.34. A method for visual programming of a computer according to claim 1 to 33, characterized in that a) that inserting, changing and deleting operations can be triggered directly in the visual program displayed on an output medium with the aid of a graphic input tool, b) that depending on the insert, change and delete position within the visual program meaningfully limits the number of possible actions and entries and this is shown to the programmer, c) that depending on the insert, change and delete position within the visual program to the programmer additional auxiliary information is displayed and d) that the objects of the memory image of the visual program are enriched with information to support the method according to a) to c).
35. Verfahren nach Anspruch 34, dadurch gekennzeichnet, daß Namens- und Typinformation für die Anzeige in Auswahllisten des Editors aus existierenden textuellen Klassenbibliotheken durch Standardverfahren der Syntaxanalyse automatisch gewonnen und klassifiziert wird.35. The method according to claim 34, characterized in that name and type information for display in selection lists of the editor from existing textual class libraries is automatically obtained and classified by standard methods of syntax analysis.
36. Verfahren zur visuellen Programmierung eines Computers nach Anspruch 1 bis 33, dadurch gekennzeichnet, a) daß das Speicherabbild des visuellen Programms in einer Traverse durchlau- fen wird, die der sequentiellen Klammerdarstellung des Objektbaumes entspricht, b) daß für jedes traversierte Objekt des Speicherabbildes gemäß seiner Klasse eine Methode aufgerufen wird, die seine Attribute auf syntaktische Elemente einer Zielsprache bzw. auf administrative Einheiten eines Betriebssystems abbildet, c) daß Klassen und ihnen untergeordnete funktionale Einheiten in den Quellcode einer Zielsprache übersetzt werden, d) daß Module und ihnen übergeordnete funktionale Einheiten in administrative Einheiten eines Betriebssystems übersetzt werden und e) daß die Objekte des Speicherabbildes mit Informationen zur Unterstützung des Verfahrens nach a) bis d) angereichert werden.36. A method for the visual programming of a computer according to claims 1 to 33, characterized in that a) the memory image of the visual program is passed through in a traverse. fen, which corresponds to the sequential parenthesis of the object tree, b) that a method is called for each traversed object of the memory map according to its class, which maps its attributes to syntactic elements of a target language or to administrative units of an operating system, c) that classes and Functional units that are subordinate to them are translated into the source code of a target language, d) that modules and functional units that are superior to them are translated into administrative units of an operating system, and e) that the objects of the memory image are enriched with information to support the method according to a) to d) .
37. Verfahren nach Anspruch 36, dadurch gekennzeichnet, daß die Definition eines Containers auf die Definition eines Templates (Klassenschablone mit Typparameter) abgebildet wird, wobei der Typ der Containerelemente auf den Typparameter des Templates abgebildet wird.37. The method according to claim 36, characterized in that the definition of a container is mapped to the definition of a template (class template with type parameter), the type of container elements being mapped to the type parameter of the template.
38. Verfahren nach Anspruch 36 und 37, dadurch gekennzeichnet, daß die Verschachtelung von Containern auf die verschachtelte Deklaration von Templates abgebildet werden.38. The method according to claim 36 and 37, characterized in that the nesting of containers are mapped to the nested declaration of templates.
39. Verfahren nach Anspruch 36 bis 38, dadurch gekennzeichnet, daß der Zugriff auf Container- elemente abgebildet wird auf einen Klammeroperator, dem ein Iterator als Parameter übergeben wird und der als Ergebnis eine Referenz auf das adressierte Containerelement zurückgibt.39. The method according to claim 36 to 38, characterized in that the access to container elements is mapped to a bracket operator to which an iterator is passed as a parameter and which as a result returns a reference to the addressed container element.
40. Verfahren nach Anspruch 36 bis 39, dadurch gekennzeichnet, daß eine Kontrollstruktur abhängig vom Typ ihrer Case-Blöcke und abhängig vom Vergleichsoperator der Postconditions auf unterschiedliche Kontrollstrukturen der Zielsprache abgebildet wird.40. The method according to claim 36 to 39, characterized in that a control structure is mapped to different control structures of the target language depending on the type of their case blocks and depending on the comparison operator of the postconditions.
41. Verfahren zur visuellen Programmierung eines Computers nach Anspruch 1 bis 33, dadurch gekennzeichnet, a) daß das Speicherabbild des visuellen Programms als zusammenhängendes Objekt mit allen seinen internen Beziehungen vom Arbeitsspeicher in eine objektorientierte Datenbank verlagert wird, b) daß das Speicherabbild als zusammenhängendes Objekt mit allen seinen internen Beziehungen aus einer objekt-orientierten Datenbank in den Arbeitsspeicher verlagert wird und c) daß das Speicherabbild zur Unterstützung des Verfahrens nach a) und b) mit zusätzlichen Informationen angereichert wird.41. A method for visual programming of a computer according to claim 1 to 33, characterized in that a) that the memory image of the visual program as a coherent object with all its internal relationships is shifted from the working memory into an object-oriented database, b) that the memory image as a coherent object with all of its internal relationships is moved from an object-oriented database into the working memory and c) that the memory image is supplemented with additional information to support the method according to a) and b).
42. Verfahren nach Anspruch 41 , dadurch gekennzeichnet, daß der selektive Zugriff auf Teile des in der objekt-orientierten Datenbank liegenden Speicherabbilds durch Standard-Suchfunktionen der objekt-orientierten Datenbank unterstützt wird.42. The method according to claim 41, characterized in that the selective access to parts of the memory image located in the object-oriented database is supported by standard search functions of the object-oriented database.
43. Verfahren nach Anspruch 41 und 42, dadurch gekennzeichnet, daß die Zugriffskontrolle für das in der objekt-orientierten Datenbank liegende Speicherabbild durch Standardfunktionen der objekt-orientierten Datenbank unterstützt wird.43. The method according to claim 41 and 42, characterized in that the access control for the memory image located in the object-oriented database is supported by standard functions of the object-oriented database.
44. Verfahren zur visuellen Programmierung eines Computers nach Anspruch 1 bis 33, dadurch gekennzeichnet, a) daß das Speicherabbild des visuellen Programms, ganz oder teilweise, in unterschiedlichen Hierarchiestufen, Abstraktionsebenen, Detaillierungsgraden und Maßstäben wiedergegeben wird, b) daß Beziehungen und Abhängigkeiten zwischen Teilen des Speicherabbildes graphisch hervorgehoben werden können, c) daß Verzweigungsebenen des Speicherabbildes drei-dimensional geschichtet und in perspektivischer Ansicht dargestellt werden, d) daß Teile der graphischen Wiedergabe des Speicherabbildes vorübergehend mit Teilen eines fremden Spei- cherabbildes graphisch überlagert werden und e) daß die Objekte des Speicherabbilds mit Informationen zur Unterstützung des Verfahrens nach a) bis d) angereichert werden.44. Method for the visual programming of a computer according to claim 1 to 33, characterized in that a) that the memory image of the visual program, in whole or in part, is reproduced in different hierarchical levels, levels of abstraction, levels of detail and scales, b) that relationships and dependencies between parts of the memory image can be highlighted graphically, c) that branching planes of the memory image are layered three-dimensionally and represented in perspective view, d) that parts of the graphic representation of the memory image are temporarily combined with parts of a foreign memory are superimposed graphically and e) that the objects of the memory image are enriched with information to support the method according to a) to d).
45. Verfahren nach Anspruch 44, dadurch gekennzeichnet, daß die Objekte des Speicherabbilds während des Editierens automatisch mit einer Kennzeichnung des Leistungsmerkmals versehen werden, dem sie zugehören und daß Objekte, die demselben Leistungsmerkmal zugehören, jederzeit graphisch hervorgehoben werden können.45. The method according to claim 44, characterized in that the objects of the memory image are automatically provided with an identifier during the editing of the feature to which they belong and that objects which belong to the same feature can be graphically highlighted at any time.
46. Verfahren nach Anspruch 44 und 45, dadurch gekennzeichnet, daß die Objekte des Speicherabbilds während des Editierens automatisch mit einer Zeitmarke versehen werden und daß Objektmengen, die verschiedenen Leistungsmerkmalen zugehören, jederzeit gemäß der zeitlichen Abfolge des Entwurfsprozesses angezeigt werden können.46. The method according to claim 44 and 45, characterized in that the objects of the memory image are automatically provided with a time stamp during editing and that object sets which belong to different performance features can be displayed at any time in accordance with the chronological sequence of the design process.
47. Verfahren zur visuellen Programmierung eines Computers nach Anspruch 1 bis 33, dadurch gekennzeichnet, a) daß unmittelbar in dem auf einem Bildschirm angezeigten visuellen Programm mithilfe eines graphischen Eingabewerkzeugs Operationen zur Eingabe von Dokumentationstex- ten, Kommentaren und andersartiger Information ausgelöst werden können, b) daß in Abhängigkeit von der Eingabeposition innerhalb des visuellen Programms die eingegebene Dokumentation einzelnen Programmelementen zugeordnet wird, c) daß die einem Programmelement zugeordnete Dokumentation während der Bearbeitung des Programms jederzeit angezeigt werden kann, d) daß für jede funktionale Einheit die Dokumentation aller ihrer Programmelemente jederzeit in geschlossener Form ausgegeben werden kann, und e) daß die Objekte des Speicherabbilds mit Attributen zur Unterstützung des Verfahrens nach a) bis d) angereichert werden.47. Method for the visual programming of a computer according to claims 1 to 33, characterized in that a) that operations for entering documentation texts, comments and other types of information can be triggered directly in the visual program displayed on a screen with the aid of a graphic input tool, b ) that depending on the input position within the visual program, the entered documentation is assigned to individual program elements, c) that the documentation assigned to a program element can be displayed at any time during the processing of the program, d) that for each functional unit, the documentation of all its program elements at all times can be output in closed form, and e) that the objects of the memory image are enriched with attributes to support the method according to a) to d).
48. Verfahren zur visuellen Programmierung eines Computers nach Anspruch 1 bis 33, dadurch gekennzeichnet, a) daß der Fertigstellungsgrad des visuellen Programms aus der attributiven und topologischen Vollständigkeit seines Speicherabbildes automatisch ermittelt wird, b) daß der Entstehungsgang des Speicherabbilds protokolliert wird und der zukünftige Projektverlauf aus dem bisherigen Entstehungsgang des Speicherabbilds automatisch ermittelt wird, c) daß die Verwaltung von Namens- und Typ-Information von Operanden und Operationen durch Standardfunktionen einer objekt-relationalen Datenbank unterstützt wird, d) daß die Verwaltung von Versionen, Entwurfsalternativen und Entwurfsmustern durch Standardfunktionen einer objekt-relationalen Datenbank unterstützt wird und e) daß die Objekte des Speicherabbildes mit Informationen zur Unterstützung des Verfahrens nach a) bis d) angereichert werden.48. Method for the visual programming of a computer according to claim 1 to 33, characterized in that a) that the degree of completion of the visual program is automatically determined from the attributive and topological completeness of its memory map, b) that the path of creation of the memory map is logged and the future course of the project it is automatically determined from the previous development of the memory image, c) that the management of name and type information of operands and operations is supported by standard functions of an object-relational database, d) that the management of versions, design alternatives and design patterns is supported by standard functions object-relational database is supported and e) that the objects of the memory image are enriched with information to support the method according to a) to d).
49. Verfahren nach Anspruch 48, dadurch gekennzeichnet, daß die Vollständigkeit des Speicherabbildes aus der Zusammengehörigkeit von Spezifikationsmerkmalen und durch Abgleich mit der Topologie und den Attributen des Speicherabbilds ermittelt wird.49. The method according to claim 48, characterized in that the completeness of the memory image is determined from the association of specification features and by comparison with the topology and the attributes of the memory image.
50. Verfahren zur visuellen Programmierung eines Computers nach Anspruch 1 bis 33, dadurch gekennzeichnet, a) daß die Anzeige der Objekte des Speicherabbilds des visuellen Programms in topologischen und assoziativen Traversen verläuft, b) daß die Anzeige der Objekte des Speicherabbilds zwischen verschiedenen Abstraktionsebenen, Detaillierungsgraden und Maßstäben wechselt, c) daß eine perspektivische Anzeige drei-dimensional angeordneter Objekte des Speicherabbilds durch allmähliche Richtungsänderung, Annäherung und Entfernung erfolgt, d) daß Hilfsinformation zur Orientierung, Dokumentation und Verwaltung angezeigt wird und e) daß die Objekte des Speicherabbilds mit Informationen zur Unterstützung des Verfahrens nach a) bis d) angereichert werden.50. Method for visual programming of a computer according to claim 1 to 33, characterized in that a) that the display of the objects of the memory image of the visual program runs in topological and associative traverses, b) that the display of the objects of the memory image between different levels of abstraction, levels of detail and scales change, c) that a perspective display of three-dimensionally arranged objects of the memory image takes place by gradual change of direction, approach and distance, d) that Auxiliary information for orientation, documentation and administration is displayed and e) that the objects of the memory image are enriched with information to support the method according to a) to d).
51. Verfahren zur visuellen Programmierung eines Computers nach Anspruch 1 bis 33, dadurch gekennzeichnet, daß Funktionsabläufe, Zusammenhänge und Abhängigkeiten innerhalb des visuellen Programms durch aufeinanderfolgende farbliche oder akustische Kennzeichnung hervorgehoben werden. 51. Method for the visual programming of a computer according to claim 1 to 33, characterized in that functional sequences, relationships and dependencies within the visual program are highlighted by successive color or acoustic identification.
PCT/DE2000/000477 1999-02-20 2000-02-16 Method and system for visual programming WO2000049498A1 (en)

Priority Applications (1)

Application Number Priority Date Filing Date Title
EP00909044A EP1161724A1 (en) 1999-02-20 2000-02-16 Method and system for visual programming

Applications Claiming Priority (2)

Application Number Priority Date Filing Date Title
DE19907328.7 1999-02-20
DE19907328A DE19907328C2 (en) 1999-02-20 1999-02-20 Visual programming method and system

Publications (1)

Publication Number Publication Date
WO2000049498A1 true WO2000049498A1 (en) 2000-08-24

Family

ID=7898277

Family Applications (1)

Application Number Title Priority Date Filing Date
PCT/DE2000/000477 WO2000049498A1 (en) 1999-02-20 2000-02-16 Method and system for visual programming

Country Status (3)

Country Link
EP (1) EP1161724A1 (en)
DE (1) DE19907328C2 (en)
WO (1) WO2000049498A1 (en)

Cited By (4)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US8589874B2 (en) 2007-06-11 2013-11-19 Microsoft Corporation Visual interface to represent scripted behaviors
US11003422B2 (en) 2019-05-10 2021-05-11 Fasility Llc Methods and systems for visual programming using polymorphic, dynamic multi-dimensional structures
CN113590086A (en) * 2020-04-30 2021-11-02 深圳中砼物联网科技有限公司 Method for quickly developing software, computer equipment and storage medium
CN111090419B (en) * 2019-11-26 2023-04-07 广东工业大学 Tree structure visualization method based on node introductivity change

Family Cites Families (11)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
AU8533582A (en) * 1981-07-10 1984-01-12 Reckitt & Colman Products Limited Stable solutions of buprenorphine
JPH0640302B2 (en) * 1984-01-30 1994-05-25 株式会社日立製作所 Schematic / source program automatic generation method
US4734854A (en) * 1985-10-08 1988-03-29 American Telephone And Telegraph Company System for generating software source code components
US5323452A (en) * 1990-12-18 1994-06-21 Bell Communications Research, Inc. Visual programming of telephone network call processing logic
US5793369A (en) * 1991-12-06 1998-08-11 Lucent Technologies Inc. Apparatus for visualizing program slices
US5539869A (en) * 1992-09-28 1996-07-23 Ford Motor Company Method and system for processing and presenting on-line, multimedia information in a tree structure
US5581797A (en) * 1993-10-22 1996-12-03 Lucent Technologies Inc. Method and apparatus for displaying hierarchical information of a large software system
CA2643234C (en) * 1993-10-29 2012-05-15 Microsoft Corporation Method and system for generating a computer program
EP0689132B1 (en) * 1994-06-23 2000-07-26 International Business Machines Corporation Visualizing object-oriented software
JPH0855019A (en) * 1994-08-10 1996-02-27 Hitachi Ltd Visual programming method
EP0706125A1 (en) * 1994-09-30 1996-04-10 International Business Machines Corporation Object oriented system and method for generating target language code

Non-Patent Citations (3)

* Cited by examiner, † Cited by third party
Title
REISS S P: "GRAPHICAL PROGRAM DEVELOPMENT WITH PECAN PROGRAM DEVELOPMENT SYSTEMS", SIGPLAN NOTICES,US,ASSOCIATION FOR COMPUTING MACHINERY, NEW YORK, NY, vol. 19, no. 5, 1 May 1984 (1984-05-01), pages 30 - 41, XP002049749, ISSN: 0362-1340 *
VILELA P R S ET AL: "PROGRAM GRAPH VISUALIZATION", SOFTWARE PRACTICE & EXPERIENCE,GB,JOHN WILEY & SONS LTD. CHICHESTER, vol. 27, no. 11, 1 November 1997 (1997-11-01), pages 1245 - 1262, XP000703782, ISSN: 0038-0644 *
WILLIAMS C S ET AL: "A VISUAL LANGUAGE FOR IMAGE PROCESSING", PROCEEDINGS IEEE WORKSHOP ON VISUAL LANGUAGES,US,LOS ALAMITOS, CA, 1 January 1990 (1990-01-01), pages 86 - 91, XP002003655 *

Cited By (5)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US8589874B2 (en) 2007-06-11 2013-11-19 Microsoft Corporation Visual interface to represent scripted behaviors
US11003422B2 (en) 2019-05-10 2021-05-11 Fasility Llc Methods and systems for visual programming using polymorphic, dynamic multi-dimensional structures
CN111090419B (en) * 2019-11-26 2023-04-07 广东工业大学 Tree structure visualization method based on node introductivity change
CN113590086A (en) * 2020-04-30 2021-11-02 深圳中砼物联网科技有限公司 Method for quickly developing software, computer equipment and storage medium
CN113590086B (en) * 2020-04-30 2023-09-12 广东中砼物联网科技有限公司 Method for rapidly developing software, computer device and storage medium

Also Published As

Publication number Publication date
DE19907328C2 (en) 2002-10-24
DE19907328A1 (en) 2000-08-31
EP1161724A1 (en) 2001-12-12

Similar Documents

Publication Publication Date Title
DE60011479T2 (en) XML ROBOT
Nanard et al. Using structured types to incorporate knowledge in hypertext
North et al. Applications of graph visualization
Trigg et al. Adaptability and tailorability in NoteCards
DE19957780A1 (en) Computer program editing system has editing effected in graphic environment by use of browser accessing layout control and editing control with editing icons and editing windows
DE10121790A1 (en) System and process for the configuration of software products uses a n extendable software configuration mark up language
DE10149693A1 (en) Objects in a computer system
DE102004043788A1 (en) Personal computing device executes program based on individual programming code to provide predefined code and to define direct relation between input and output of data by user and attribute of classes in input model
DE69907714T2 (en) COMPONENT-BASED SOURCE CODE GENERATOR METHOD
Pareja-Flores et al. WinHIPE: An IDE for functional programming based on rewriting and visualization
Cremer et al. Graph‐based tools for re‐engineering
Gaines Class library implementation of an open architecture knowledge support system
DE19907328C2 (en) Visual programming method and system
DE102019008598A1 (en) Identification and visualization of associations between code generated by a model and sources that influence code generation
Renggli et al. Magritte–a meta-driven approach to empower developers and end users
Consens Creating and filtering structural data visualizations using hygraph patterns.
Montero et al. Formalization of web design patterns using ontologies
Bardohl Visual definition of visual languages based on algebraic graph transformation
EP0519096B1 (en) Knowledge based diagnostic system with graphical knowledge-acquisition element
Almeida et al. A tool for programming with interaction nets
Keller et al. Towards comprehensive support for the dynamic analysis of Petri net based models
Minör et al. Using mjølner orm as a structure-based meta environment
Shum et al. AOPS: an abstraction-oriented programming system for literate programming
Junker Flexible Graphical Editors for Extensible Modular Meta Models
Gotlieb et al. Data schemata based on directed graphs

Legal Events

Date Code Title Description
AK Designated states

Kind code of ref document: A1

Designated state(s): JP US

AL Designated countries for regional patents

Kind code of ref document: A1

Designated state(s): AT BE CH CY DE DK ES FI FR GB GR IE IT LU MC NL PT SE

121 Ep: the epo has been informed by wipo that ep was designated in this application
DFPE Request for preliminary examination filed prior to expiration of 19th month from priority date (pct application filed before 20040101)
WWE Wipo information: entry into national phase

Ref document number: 2000909044

Country of ref document: EP

WWE Wipo information: entry into national phase

Ref document number: 09914094

Country of ref document: US

WWP Wipo information: published in national office

Ref document number: 2000909044

Country of ref document: EP

WWW Wipo information: withdrawn in national office

Ref document number: 2000909044

Country of ref document: EP