text:
Nara Business Cards
More and more clients are starting to request split fountain printing, where we put two ink colors on the same roller to acheive a gradient. Craig Duffney, a longtime friend of Studio On Fire, designed these cards for Nara, a web personalization tool. In this instance, the pink to purple split fountain is a direct callback to the gradient background of the Nara website. After two passes through the press and duplexing back to themselves, the cards were finished with a custom rounded corner diecut. Letterpress printed on Neenah Classic Crest Solar White 200C.


text:
US6763498B2 - Graphical environment for managing and developing applications - Google PatentsGraphical environment for managing and developing applications Download PDF
- Publication number
- Authority
- United States
- Prior art keywords
- application
- program module
- program
- module
- user
- Prior art date
- Legal status (The legal status 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 status listed.)
- Expired - Lifetime, expires
- 238000003860 storage Methods 0 Claims Description 8
- 230000001276 controlling effects Effects 0 Claims 1
- 230000003213 activating Effects 0 Description 2
- 230000003935 attention Effects 0 Description 1
- 238000004422 calculation algorithm Methods 0 Description 2
- 238000004364 calculation methods Methods 0 Description 1
- 238000004590 computer program Methods 0 Description 1
- 230000000875 corresponding Effects 0 Description 6
- 230000001419 dependent Effects 0 Description 1
- 230000018109 developmental process Effects 0 Description 4
- 230000002708 enhancing Effects 0 Description 1
- 239000011519 fill dirt Substances 0 Description 1
- 238000002372 labelling Methods 0 Description 1
- 239000002609 media Substances 0 Description 1
- 230000015654 memory Effects 0 Description 1
- 238000000034 methods Methods 0 Description 10
- 230000004048 modification Effects 0 Description 3
- 238000006011 modification Methods 0 Description 3
- 230000000051 modifying Effects 0 Description 1
- 230000036961 partial Effects 0 Description 1
- 230000002829 reduced Effects 0 Description 1
- 230000002104 routine Effects 0 Description 1
- 230000001960 triggered Effects 0 Description 3
- 230000000007 visual effect Effects 0 Description 2
- G06F8/00—Arrangements for software engineering
- G06F8/30—Creation or generation of source code
- G06F8/34—Graphical or visual programming
This application is a divisional of application Ser. No. 08/690,919, filed on Aug. 1, 1996, now U.S. Pat. No. 6,286,017 which is CIP of prior application Ser. No. 08/392,164, filed on Feb. 22, 1995, now abandoned the entire contents of which are hereby incorporated by reference and for which priority is claimed under 35 U.S.C. §120.
In general the present invention relates to an application building environment. More specifically, the present invention relates to an application building and managing environment in which users of computer systems, including ones with minimal programming knowledge, create and share powerful software applications.
In a conventional application building environment such as in most third and fourth generation programming languages, the task of constructing an application requires intensive knowledge of specialized methods and structures. Existing application environments do not enable end-users with limited programming knowledge to combine program modules from other users and program developers into complicated applications. The sharing of program components is done on a level inaccessible by the end-user. Furthermore, existing systems do not combine programming at different skill and complication levels into a unified environment where complex programming and simple end-user programming follow the same approach. The components of an application are usually rigorously embedded into the program source code either in the form of text or as a combination of text and objects. This results in difficulties in sharing computer components. Module and data dictionaries and well organized program libraries provide a partial solution to this problem. However there are still very limited possibilities for end-users of computer systems to share or even build complicated applications involving rich modular programming structure without intensive knowledge of a complicated programming environment.
The introduction of multidimensional spreadsheets allows users of such systems to create more complicated calculation models through a smooth transaction from two-dimensional spreadsheets and is thus a step toward making applications manageable by the end-user. Current spreadsheet systems however do not focus the user's attention on the underlying logical modular structure ever-present in an application. Furthermore current spreadsheet systems do not generalize the spreadsheet concept in such a way that powerful programming techniques can be applied without leaving the methodology of the spreadsheet environment but instead employ add-on techniques such as the writing of macros to enhance usability.
There exist numerous source code generators and fourth generation programming environments using graphical structures as part of application generation. Source code generators however and most other application building environments, by definition, are intended for program development and provide an environment for developing applications which is entirely different from the end-user environment. Thus the end user is separated from the application building environment and is unable to create or share application components without moving up to the application developing level.
U.S. Pat. No. 4,956,773, issued Sep. 11, 1990 to Saito et al., describes methods for creating programs using various diagrams. The Saito patent is directed to an apparatus for automatically creating a source program, in particular the coding of the source program is automatically performed from program specifications which the programmer generates, in order to reduce the burden required to create such a source program. As illustrated in FIG. 11 of Saito, the source code is automatically generated from a module structure diagram.
U.S. Pat. No. 5,255,363, issued Oct. 19, 1993 to Seyler, describes methods for writing programs within a spreadsheet application. The Seyler patent is directed to a graphical programming system with a spreadsheet base for enabling users to create graphical programs for displaying and manipulating data. The Seyler invention allows a user to create graphical programs which can monitor parameters (such as cost and reliability) and provide feedback during the design of electronic systems, such as circuit boards.
U.S. Pat. No. 5,317,686, issued May 31, 1994 to Salas et al., describes relabeling of spreadsheet cells. The Salas et al patent is directed to an apparatus and labeling scheme which permits a user to reformat, redefine, and relabel the various cells of a multidimensional spreadsheet The Salas et al patent also permits the creation of multidimensional spreadsheets where calculations are specified through general, rather than per cell, formulae.
An object of the present invention is to provide a graphical application developing and managing environment in which the building and sharing of application components is done largely by the end-user.
The above object is accomplished by combining a graphical logical modular structure diagram, methods for embedding source code for a class of programming languages into a visual spreadsheet-like format, and standardized interfaces into modules and external applications.
Central to the present invention is the definition of an indication value system which allows spreadsheet methodology to be applied to an advanced functional language. The indication value system is an extremely practical invention since it empowers the spreadsheet user to create general software applications without having to abandon the spreadsheet methodology. It thus addresses the well known challenge of end-user empowerment in the creation of software components.
Modular structure is present in any software application and can be visualized in many different ways depending on which program parts are grouped together to form a module and how they are interconnected. However the term logical modular structure used above represents a modular structure describing a solution to a specific task an application is intended to perform.
According to the present invention, application or module building can be done by drawing on a display unit a logical modular structure diagram describing how the new module is connected to other modules representing existing applications, previously written modules and unfinished modules. Using this diagram detailed description about the application is attached to the various parts of the diagram so as to represent the flow of information between the modules and the manipulation and visual representation of information. The new module is assigned an interface part. The interface part is a standardized interface, through which future applications communicate, and which can be used as an interface to external applications such as databases. The present invention thus enables the creation of standardized interfaces, visually represented, into modules including modules which overlay external applications.
The present invention provides methods for using as an equivalent alternative to the text format a spreadsheet-like format when writing and executing source code written in a functional programming language, methods for moving back and forth from the spreadsheet format and the traditional text format and methods for attaching source code to the parts of the above logical modular structure diagram.
There exist many different ways to define statements in a functional language, or any language for that matter, other than using traditional text definitions. The methods described herein also apply in cases when alternatives to the text format are used. This can be verified by noticing that one can translate alternative representations of code into the traditional text format. The patchwork mechanism, which will be described in details below, can be considered to be a graphical representation/definition of statements defining calls to child modules and is thus an example of an alternative to the text format for such statements. The patchwork mechanism employs the cell format, described herein also, to define parent-child module relationships in an end-user friendly way.
The term functional programming language or a functional language refers to a programming language in which each statement written in the language can be evaluated, based on its dependent variables, to a uniquely defined value of some type. This does not automatically exclude languages in which order of execution is important, since we do not require the languages to be "pure functional languages", see for example in the literature: Sethi, Ravi. Programming Languages, Addison-Wesley Publishing Company, 1990. The term advanced functional language applies to a functional language which can be used to handle and return more complex variables than the basic variable types text and number. An example of a very simple source code (module Audio) written according to the above principle is shown in connection with the description of FIG. 8.
In one aspect, the invention relates to a method for visually representing in a computer system a program specification, i.e., source code, written in an advanced functional language in a spreadsheet-like cell format and for allowing the execution of the program specification within the cell format. The method comprises:
communicating with a display device connected to a process device,
accessing a cell frame containing multiple cells displayed on said display device,
displaying text and icons in said cell frame,
associating selected variables and corresponding definitions in said program specification with cells in said cell format,
determining values of said selected variables by executing said program specification, and
displaying in cells, associated with said selected variables, an indication value determined by an indication function representing values of said selected variables.
The invention also relates to a system which is suitable for performing the method. The system comprises
(a) Means for communicating with a display device connected to a process device. In a normal setting, this may be a program which through the operating system of the computer displays cell-frames, text and figures on a display device.
(b) Means for accessing a cell frame containing multiple cells displayed on said display device. This may be provided, via a computer program, by naming the cells and by tracking information about the cells such as location and content.
(c) Means for displaying text and icons in said cell frame. This may be a program capable of changing the content of a cell on request.
(d) Means for associating selected variables and their definitions in said program specification to cells in said cell format. This may be a program connecting variable names from the source code to cell names in the cell frame.
(e) Means for determining values of said selected variables by executing said program specification. This may be a compiler and a parser or an interpreter of the programming language used.
(f) Means for displaying in cells, associated to said selected variables, an indication value determined by an indication function representing values of said selected variables. This may be a program implementing an indication function capable of displaying in a cell, an indication value of a variable, defined in the source code by a statement written in an advanced functional language and associated with the cell, representing objects of a more general nature than formatted text or numbers. Such objects are, for example, tables from a database, databases, rows from tables, sound and video specifications, geometrical figures, program parts such as forms, mathematical formulas and many other objects.
Normal spreadsheet systems do not extend to allow the general representation of code written/created in an advanced functional language as discussed in the present description.
In important embodiments, the system includes means for displaying the full value of a variable associated to a cell in the cell format. This may be a program communicating to the user additional information about the object referred to by the value associated with the cell and possibly submitting the value to another system capable of providing insight into the value when such a system is available. Displaying the full value thus attempts to display a value in a system native to the value. An example of a full value would be to open up a table frame to display the content of a table referred to in a cell. This is done, depending on the embodiment, by submitting the table value to a system capable of displaying and possibly allowing the editing of the content of the table in a table frame or including a procedure capable of displaying the content of the table in the embodiment itself. Another example is submitting a sound variable, referred to in a cell, to a sound system thus allowing the user to play or edit the sound within the system.
In any practical embodiment the system should include means for editing the statement defining the variable associated to a cell in the cell format. These means may, e.g., be provided by a program implementing a text editor displaying the definition of a statement associated to a cell, upon request, and allowing the user to edit the statement definition similar to the editing of functions and formulas in most spreadsheet applications. This occurs at a lower level connecting an input device and a process device in a way which enables the editing.
In some cases it may be convenient for the user to be able to view some part of the program specifications in a pure text format and the invention provides means for doing that and for going between the two formats, i.e., the cell and the standard text format. This feature may be provided by using the standard text format and by implementing a translation algorithm, see, e.g., FIG. 10 and FIG. 11, to move back and forth between the display formats.
In an embodiment of the invention, the cell format is used together with additional means to structure and visualize the writing and editing of a program application further. A system suitable for this embodiment would further include means comprising:
(a) Means for communicating with an input device connected to the process device for allowing the editing of text and figures.
(h) Means, provided, e.g., by a program capable of drawing parent-child relational diagrams, for displaying a modular structure diagram on the display device representing the call declarations part of the program specification.
(i) Means for organizing the remaining program specification, excluding the call declarations, of said program specification into predetermined smaller parts each containing a selection of variables and their definitions. This may be a program, usually part of the parsing mechanism and possibly accepting user input, to classify the statements in said program specification.
(j) Means for displaying at least some of said parts and, if desired, each of said parts, on the display device. This feature may be provided by displaying the statements in each part either in text or cell format.
(k) Means for editing or creating the program specification by editing at least some of said parts and/or by editing said modular structure diagram. The editing of the statements in text or cell format may be done by a text editor as described above. Editing said modular structure diagram is usually done with a graphical editor capable of representing parent-child modular relationships, and the resulting modular structure is translated to conform to the programming language used.
In most programming languages, code can be divided into several parts which are expressed differently in different languages, but serve the same purpose. Such a division is obtained by classifying program specifications into input declarations, output declarations, call declarations, call definitions and program statements. For this division it is assumed that said input declarations, when assigned values, define values of said output declarations using said output declarations, said call declarations, said call definitions and said program statements. It is also assumed that said call definitions define a flow of information through the modular structure existing in the program and that the modular structure is described by said call declarations. An embodiment of the invention uses this classification and represents each of the parts, not necessarily independently, in various formats for viewing, execution, tracing and editing.
Logically this classification is related to the modular structure diagram and, in an embodiment, an association is created between areas of the diagram, for example knots representing modules and lines representing the flow between modules, by assigning at least some of the program parts, or if desired each of the program parts, excluding call declarations, to specific areas or objects of the diagram. The user can then access a specific part of the program specifications by using an input/pointing device to designate an object or area of the modular structure diagram. These additional means may be implemented using well-known program routines.
In another aspect, the invention relates to an application building and sharing environment, comprising:
(a) A collection of, possibly user defined, program modules stored on storage devices.
(b) Display means capable of defining a work area on a display device.
(c) Module organizing means for organizing a program module from said collection into predefined parts including an interface part, call declaration part and call definition part. These means may be provided by a program, usually part of the parsing mechanism and possibly accepting and storing user input at some point, to classify the statements in said program module.
(d) Icon representation means capable of assigning icons to at least some of the program modules, or if desired each of the program modules, from said collection and capable of displaying said icons on the work area. This feature may be provided by associating each module to a geometrical figure or a bitmap and possibly also text and displaying the resulting figure and text on said work area.
(e) Interface representation means capable of displaying, on the work area, said interface part of a program module from said collection in a cell format, using indication values.
(f) Data flow representation means capable of displaying, on said work area using a cell format, the call definition part of a parent-child module relationship within a program module from said collection. Examples are explained in connection with FIG. 7.
(g) Structure means capable of displaying on the work area a modular structure diagram for a program module from the collection graphically, representing the parent-child module relationships declaration part within the program module, see, e.g., FIG. 4.
(h) Sharing means to allow a user to select program modules from said collection and represent a selected program module by its icon on said work area. This feature may, in one embodiment, be provided by a shared folder-like system allowing the user to select the program module and locate it on the work area using an input/pointing device.
(i) Program module editing means capable of allowing the user to edit and add program modules to said collection by editing each of said predefined parts of a program module from said collection.
(j) Program module execution means capable of determining and displaying, using the interface cell format of a program module from said collection, indication values representing results of executing said program module definitions. This feature may be provided by an algorithm implementing an indication function after the execution (implies parsing and compiling or interpreting) of the code has assigned values to the relevant variables.
One embodiment of the environment is implemented as follows. The above program module editing means allow a user of the application environment to edit graphically said modular structure diagram to create and delete parent-child relationships within the module. The data flow definitions are edited within the data flow cell format, explained in connection with FIG. 7, and wherein said interface part is edited within the interface cell format, see FIG. 5 and FIG. 6. The graphical editing of the modular structure (call declarations) and the editing of the flow between modules using the data flow cell format defines a patchwork mechanism in the environment. Thus, it becomes possible for the user to define program and flow variables and view their values simultaneously using a patchwork mechanism.
For a user not allowed to change the definition of a particular module in the collection, this will be sufficient to allow the user to view results obtained by executing the module. In order to be able to define the module, using the cell format, the environment must not exclude the remaining statements (the program part) from being edited in the cell format.
In an application environment, in which users have access to shared programming modules, there should be some way to control the access of the individuals to the modules. In an embodiment, his may be provided by associating with each module, information about the privileges required to use the module and comparing it to privileges of users trying to access the module.
In a preferred embodiment of the environment it is important to be able to adjust to at least some other existing programming environments. This may be achieved by implementing a compiler, for the programming language used, returning object code compatible to other systems, also referred to here as exporting a module to another system.
The above application building and sharing environment may further include means for associating and displaying with the module icon, of a program module from above collection, icons representing user selected variables within the program module specification. This feature may be provided by associating a control icon, usually a button, with a specific variable in the program specification. Then means for allowing a user to access the full value of the variable, associated to the control icon, may be provided by executing, upon request, the program parts needed to define the variable and when the variable value has been determined the full value is displayed. Since, for non-constants, the value of a variable in a module is only defined when the input variables are defined, this assumes that the system has available input values for the module. A suitable way is to store, for each user, the input values used in the last execution of the module or a set of default input values. In a spreadsheet system this is always the case, i.e., values are not removed from the cells after execution of the program.
In yet another aspect, the invention relates to a method of representing with an application (e.g. module) icon, at least some of the executable parts from within an application. A system useful for performing this method comprises:
(a) A program module, defining an application, specified using an advanced functional language.
(b) An icon representing said application.
(c) Means for displaying icons on a display device.
(d) Means for allowing a user to select variables from within said program module and represent at least some of the selected variable independently with a respective icon (such as icon 402 shown on FIG. 4). This feature is provided by enabling the user to choose from the source code which variables should be represented individually.
(e) Means for allowing the user to define the display positions of the variable icons relative to the application icon. This may be done by storing and using the relative position, selected by the user, of the variable icon.
(f) Means for displaying the application icon and the variable icons on a display device in the configuration determined by the user. This feature is usually provided by a figure and bitmap display mechanism and by retrieving the relative position of each of the variable icons from storage.
(g) Means for communicating with an input/pointing device and displaying the full value of at least some of the variables selected when the associated variable icon is designated by said input device. This feature is provided in a manner similar to the feature discussed above and requires the system to have available input values for the module.
This generates a setting in which a user of the application can execute, at run-time, each of the selected variables from within the application. In the case of a value pointing to an external document or object, this allows the user to access the (selected) external documents used in the program module.
Updating child modules in the system generates the well known problem of compatibility with existing parent modules. This issue is addressed by providing the system with ways to graphically represent multiple versions of modules as explained in connection with FIG. 4.
Thus, the system includes means for storing multiple versions of said program module and means for displaying with the application icon a time axis and time icons, means for associating to at least some of the time icons a specific version of said program module and means for displaying the icon configuration according to the version associated to a time icon designated by said input device. Using time axes in accordance with this embodiment can, of course, be generalized, beyond the environments otherwise discussed herein, to more generalized settings in graphical environments where multiple versions of programs are used. Thus, this use of time axes and icons constitutes a special, independent aspect of the present invention.
Practical Application of the Present Invention
The present invention provides an environment (including a system, method, and medium) which enables an end-user, who may have fairly limited programming language skills, to develop application programs. This is done by providing methods which extend the methodology of a spreadsheet system to a complete application development environment. The spreadsheet methodology is extended to a complete functional language keeping the advantages of spreadsheets for the end-user intact. Thus the invention makes use of the knowledge of a spreadsheet user, to create program applications. Further, the invention provides ways to utilize the spreadsheet extension in a patchwork mechanism which allows the developer and the end-user to share program components in an end-user friendly way. As a result, the cost of development and maintenance of new application programs will be significantly reduced because the invention utilizes to a greater extent the knowledge of the user. Moreover the invention provides cost efficiency by allowing reuse and sharing of program modules between end-users and developers with different background by combining the spreadsheet extension with other end-user friendly paradigms.
The present invention will become more fully understood from the detailed description given hereinafter and the accompanying drawings which are given by way of illustration only, and thus are not limitative of the present invention, and wherein:
FIG. 1 is a schematic block diagram of a system arrangement for the present invention.
FIG. 2 is a conceptual diagram showing a program module divided into parts representing program parts defining the module; also shown are external applications used in the module definition.
FIG. 3 is a conceptual diagram showing a relationship between a parent module and child modules.
FIG. 4 shows modules and external applications represented by icons and relationships between parent and child modules represented by a modular structure diagram.
FIG. 5 explains the embedding of a program module into a cell format.
FIG. 6 explains the embedding of a program module into a mixed text and cell format.
FIG. 7 explains the embedding of data flow specifications between parent and child modules into a cell format.
FIG. 8 is an overview diagram showing how the various parts of a program module on a text or other, form are represented visually.
FIG. 9 is a flow chart for displaying a variable value of a statement in a functional language in a cell.
FIG. 10 is a flow chart for embedding a program source code on text, or equivalent, format into a cell format.
FIG. 11 is a flow chart for translating source code on cell format into text format.
FIG. 12 is a flow chart for responding to a command to display the full value of a variable.
FIG. 13 is a schematic block diagram explaining multiple display formats.
FIG. 14 is a block diagram explaining the process of exporting module definitions to other systems and using module definitions with a form designer.
FIG. 15 and FIG. 16 are used in connection with an example presented.
Further scope of applicability of the present invention will become apparent from the detailed description given hereinafter. However, it should be understood that the detailed description and specific examples, while indicating preferred embodiments of the invention, are given by way of illustration only, since various changes and modifications within the spirit and scope of the invention will become apparent to those skilled in the art from this detailed description.
In the following, examples of embodiments of the present invention are described.
FIG. 1 shows a computer system (100) arrangement for performing the present invention. Numeral 101 denotes one or more CPU, 102 denotes computer memory, 103 denotes data storage such as hard disks or any other type of data storage, 105 denotes one or more input devices such as a pointing device and a keyboard, 106 denotes one or more display devices capable of displaying graphical and geometrical figures and text 107 denotes zero or more output devices such as a printer. Numeral 104 designates one or more processors, operating systems and mechanisms connecting 101, 102, 103, 104, 105, 106 and 107 into a computer system (100). This arrangement includes, but is not limited to, computers connected together by a network.
FIG. 2 illustrates a generic module. A generic module (202) includes an interface part (205), connections to other modules (206), data flow specifications between modules (207) and other program statements (208). Interface part 205 is composed from input (203) and output (204) specifications. Specifications 203, 204, 206, 207 and 208 define output 204, sometimes called results, as a function of input 203. The specifications (203, 204, 206, 207 and 208) form a program specification (209) defining module 202. Statements in specification 209 can include statements referring to and using other documents or applications (201). The statements in module (202) can be created using traditional text format or other alternative formats.
FIG. 3 illustrates relationships (301) between modules. A module (302) of type 202, referred to as parent module, uses results from other modules, called child modules, by specifying input values or conditions for interface part 205 of child modules. Existence of relationships 301 is specified in the connections part 206, sometimes called call declarations, of module 302 and the flow of data between parent module 302 and child modules, sometimes called call definitions, is specified in flow part 207 of module 302.
FIG. 4 shows an icon (401) representing module 302. Icon 401 is connected to other icons related to the module such as an icon (402) representing an external application variable. Each child module is assigned an icon (one of which is numbered 404) and each parent-child relationship is assigned an icon (one of which is numbered 403, usually a curve) connecting icon 401 to a child module icon. Each icon is assigned methods capable of responding to input devices 105. This defines a diagram (405) called a modular structure diagram and is displayed on a display device. Diagram 405 replaces the need for text specification for call declarations 206 for module 302, and a user is allowed to create a graphical figure 405 instead of writing specifications 206. To icon 401 the user has the option of associating another icon (406) referred to here as time axis. On icon 406, time axis, time icons (407) are located representing different versions of module specifications 209 for module 302. Which versions are represented by icons (e.g. 407) is determined by the user(s) creating the module specifications. Versions of specification 209 for module 302 for which a time icon is placed on time axis 406 are stored along with the current version of the specification. Modules having time axis associated with them are displayed in modular structure diagrams by their icons and with or without the time axis icon depending on whether the current version of specifications is to be used or an older version is selected. The version selected is represented by a time icon (408) having attributes or shapes distinguishing it from other time icons on the time axis.
FIG. 5 shows program module 302 represented in a spreadsheet like format (504), called cell format here, composed of cells displayed on a display device. Cell format 504 contains areas designated as input variables (501) also denoted by i1, i2, . . . , output variables (502) also denoted by o1, o2, . . . and manipulation variables (503) defining respectively input 203, output 204 and program part 208 of module 302. Cell format 504 defines the input, output and program part of module 302 by a functional language embedded and viewed in the cell format as described by flow chart 901 and explained below. Cell format 504 also defines a runtime environment for module 302 by allowing the user to modify definitions of cells and simultaneously view result of program operations as is standard within spreadsheet environments.
FIG. 6 shows program module 302 viewed in a mixed cell—and text or equivalent, format (601) composed of cells 501 and 502 representing input and output variables and program code 208 represented by a text area (602) containing a program source code (603). Source code 603 together with 501 and 502 define elements number 208, 203 and 204 of module 302 respectively. Flow charts 1001 and 1101 together with flow chart 901 provide methods for translating between text format 602 and cell format 503, if program source code 603 is written in a functional language. Format 601 allows users to view results of program operations and modify program definitions simultaneously through cells 501 and 502 as in format 504. A mixed cell—and text, or equivalent, format enables the user to choose a programming environment best suitable and enables the usage of more than one programming languages. Users select which format to work with, to define and use module 302, by means of input devices 105 by choosing from methods attached to icon 401. A full text, or equivalent, format is possible and can be translated back and forth to a full cell format or mixed format assuming that the specification is done using a functional language.
FIG. 7 shows the data flow specifications 301 between parent module 302 and a single child module (702). Data flow specifications 301 is represented in a spreadsheet like cell format (701) by denoting the rows in 701 by input variables 203 (denoted by i′1, i′2, . . . ) and output variables (denoted by o′1, o′2, . . . ) 204 from interface part 205 of module 702. Columns are denoted by call variables (denoted by c1, c2, . . . ) in such a way that each column c1, c2, . . . corresponds to a call to child module 702 with input values in rows i′1, i′2, . . . and results shown in rows o′1, o′2, . . . if the user chooses to view results at the same time as specifying data flow 301. Values passed back and forth through relationship 301 are of a general type determined by the programming language in which program specification 209 of module 302 is specified in and the values are embedded into cell format by methods described by flow chart 901. An alias (denoted by A in 701) is assigned to the relationship between parent module 302 and child module 702. Variables (denoted by A:c1:i′1, . . . , A:c2:o′2, . . . ) in cell format 701 are made available to specification 209 of module 302. Each parent-child relationship of module 302 is assigned a user editable flow specification similar to 701 and in this way call definition part 207 of module 302 is replaced by a spreadsheet like environment. Methods for accessing the data flow specifications between parent modules and child modules are attached to icons (e.g. 403) between the modules.
FIG. 8 provides an overview over how in the present invention each part of program specification 209 is represented graphically or in cell format replacing the need for a text specification defining 209. Module 302 is represented by icon 401 and time axis 406 to specify version as indicated by line 801 and explained in FIG. 4. Call declarations 206 for module 302 are represented by modular structure diagram 405 as indicated by 802 and explained in FIG. 4 also. Interface part 205 of module 302 is represented by cell format 501 for input declarations 203 and by cell format 502 for output declarations 204 as indicated by lines 804 and 805 respectively and explained in FIG. 5. Program statements 208 of module 302 are represented by, spreadsheet like, cell format 503, as indicated by line 806, or by text format 602 and explained in FIG. 5 and FIG. 6 respectively. Call definitions 207 of module 302 defining the data flow between modules are represented by sheets of cell format 701 one sheet for each relationship in modular structure diagram 405 as is explained in FIG. 7 and indicated by line 803. Interface part 205 of module 302 defines how other modules can access module 302 and in particular can be considered a interface into external applications 201 of module 302 or more generally a interface into a process which combines information from all modules in modular structure diagram 405 and connected external applications if present. Type definitions of variables used in input—203, output—204, call definitions 207 and program statements 208 are associated to their corresponding cells in the cell format.
In the preferred embodiment all definitions of modules, representations, users, and icons are stored in a centrally located database (in data storage 103) accessible to all users. Users share access to modules by placing icons (e.g. 401) in a folder directory structure, also stored in the database, defining access rights of other users and associating a description of the module to the icon for clarity. This enables the sharing of components between users of the system (e.g. network) having different programming skills, including users with only knowledge of spreadsheet systems, since data flow between modules can be defined using cell format (e.g. 701) and a runtime environment is defined by a cell format also (e.g. 501 and 502). In order to access a particular module, the user, using input devices 105, selects it from its folder, shown on a display device, and places it in a modular structure diagram describing a new application or activates it (e.g. runtime environment 504). In the preferred embodiment, compiling of modules is done relative to cells viewed at each moment on the display device used and all changes in underlying structures are reflected immediately. Users are warned and informed about how changes in module definitions affect other modules and have the option of using time axis to leave parent-child relationships unchanged. The usage of time axis allows existing modules to function unchanged when modules are upgraded.
This example refers to FIG. 15 and FIG. 16. Here some of the features shown in FIG. 8 are explained. The following is a simple source code written in text format. The language used is classified as an "advanced functional language" by the definition used earlier. The module (Audio) searches a table (B2 or "OPERAS.DB") containing sound files and locates the sound according to a keyword (B5) in the default key for the table. The variable B3 represents the row in the table containing the sound specification (B7). The sound specification is in a column of the table with the heading "SOUND".
Module Audio
-Input(B5 string)
-Output(B7 sound)
B2:=table("C:\SOUND"; "OPERAS.DB").
B3:=row(B2; B5).
B7:=item(B3; "SOUND").
When viewed in cell format the input 203, output 204 and the program statements 208 for the above source code are shown using indication values resulting from some choice (made by the user) of input values (B5 here, in the below B5 is assigned the keyword "Otello"). Evaluation of the module binds the variable B2 to a table object "OPERAS.DB" located on a storage device indexed by "C:\SOUND" in this case. The indication value for B2 is "Operas" which informs the user of the system that variable B2 points to a table named "Operas". The variable B2 is then referred to in other cells, e.g., the formula row(B2; B5) defines cell/variable B3, in the same way as in a normal spreadsheet application. When the user is editing a particular cell the original definition of the variable is displayed, e.g., when editing cell B2 the text table("C:\SOUND"; "OPERAS.DB") is used. Similarly the variable B3 is assigned to a row of the table and has indication value "Otello" and the resulting sound object located in the table and assigned to variable/cell B7 has indication value "Otello". An embodiment could thus represent the module using cell format 501, 502 and 503 as shown in FIG. 15.
When editing the cells B2, B3 and B7 the actual text definitions in the source code appear as formulas defining the values shown. When editing the input cell/variable B5 the input value chosen is displayed for editing, here "Otello".
In some embodiments the text definitions of all or some of the variables B2, B3 and B7 will be replaced by other alternative ways to define and edit the variables.
In order to access the above Audio module from another module (Enhanced Audio below) the user places the audio module as a child module in a modular diagram, shown in FIG. 16.
Defining the flow (call definition) between the new module and the Audio module is then done by the user using cell format 701 as shown in FIG. 16. In the above the input variable of the Audio module (named here Audio:Selected:B5) is assigned the value "Don Giovanni" and the resulting sound object is assigned to the variable indexed (named) by "Audio:Selected:B7" and shown using indication value "(R) Don Giovanni". The variable "Audio:Selected:B7" is recognized in the module Enhanced Audio in FIG. 16 and is used to refer to the sound object resulting from the call to the Audio module.
FIG. 9 shows flow chart (901) describing a method for displaying a variable value of a general type in a cell in such a way that extends the way mathematical formulas with number values and text is viewed in cells. A variable—or a cell value, can be considered an array holding information about the value as determined by the variable type and the variable definition. The value array is associated to the cell holding the variable/cell definition. Information in the variable/cell value array is entered into the array by a program execution mechanism which updates the value array to reflect changes in other related variables/cells or in the variable/cell definition itself. One type of the information in the array is the variable type. The program execution mechanism also triggers the display mechanism to change the displayed value of the cell. Values considered are of general types such as a number, formula, array, geometrical object, form, database, table or a row type as determined by the programming language. A variable of a text or number type is displayed in a cell by its formatted value. The same applies to some other types such as date and time. In preferred embodiments, values of more general types are displayed in cells by applying a function, called indication function here to the value array which specifies a method, based on the value type, for determining the displayed cell value of the variable. The resulting displayed cell value is a combination of text and icons fitting into a cell. The icons are selected from an icon font and combined with the text to form the cell display. Attributes such as color can be applied to the cells in a standard way. An example of such a function is an indication function which assigns to a variable an icon, representing the variable type, and concatenates to the icon a keyword selected from the information about the variable in the variable array. A value resulting from applying the indication function to a variable is referred to as the indication value of the variable. The variable array is not displayed but is associated to the cell. As is standard with spreadsheets, a syntax error in the definition of a variable is indicated with an error flag in the cell. Flow chart 1201 describes a method for viewing a variable of a general type in another way namely by its full value.
FIG. 10 shows a flow chart (1001) for embedding a program source code on text, or equivalent, format into a cell format assuming that the programming language used is a functional language. Each statement in a functional language is associated with a variable of some general type and it is therefore possible to associate each statement and its variable to a cell in a cell format as described below. The mechanism described by the flow chart reads the statements in the source code and determines (1002 and 1003) into which cell to put each statement. To which cell a statement belongs, can be determined by its variable name, information in a cross reference table about a previous embedding from a cell format into text format (see flow chart 1101) and adjusted during modification of the text to keep track of variables, user input and sequential mapping (that is a mapping of variables into some area containing enough cells). The mechanism shown stores separately information about the text, or other, format, not used in the cell format, such as the sequential order of the statements in the text (1004). The mechanism shown also reads information about a previous cell format for the program, if one exists, and formats the cell format accordingly. Once a location for the statement in a cell and existing attributes have been determined by the above measures, the variable name for the statement and the cell name are equated and the variable type is registered in the type array associated to the cell (1005). Conflicts which arise from naming of statement variables are resolved by always mapping a statement, whose variable name is the name of a cell in the cell format into the corresponding cell. Variable values are then displayed in the cell format (1006) as described by flow chart 901 for each cell after a compiling and parsing mechanism has been activated to determine the variable/cell value array for each cell used. The program is then edited in the cell format in a similar way as a conventional spreadsheet. When adding or modifying statements in a cell format the variable type is determined from the syntax of the statement entered but can, when more than one types are possible, be adjusted by the user.
FIG. 11 shows a flow chart (1101) for translating source code on cell format into text or equivalent, format. The mechanism described by the flow chart reads the statement associated to each cell and determines which variable name to use in the text format for the statement (1102 and 1103). Which variable name to use for a cell can be determined by the cell name or by a translating table (referred to in flow charts as cell cross reference table). The translating table may contain information from a previous embedding of the source code into cell format. Statements in the source code are modified to use the variable name instead of the cell name and attributes and information about the cells are stored separately (1104) to allow for an embedding back into cell format. Information from a previous embedding into cell format can be used along with other methods such as sequential ordering of statements in text and using current attributes of statements in cells to place and format statements in the text format. Statements are written into the text format (1105) and assigned to their corresponding variables. Information about the type of a variable is contained in the value array associated to the variable cell in the cell format and variables in the text format are declared accordingly using the format specified by the (functional) language used.
FIG. 12 shows a flow chart (1201) describing a mechanism for displaying the full value, by definition here, of a variable/cell value. This mechanism is triggered for a cell in a cell format by the user using an input device such as a mouse. The mechanism uses a classification of variables by types to determine methods for displaying the full value of a variable value. information contained in the variable/cell value array associated to a cell in a cell format points to and is centered around external documents for many variable types. Example of such types are table types representing database tables in database systems, graphical—and picture types, sound types representing sound specifications, types representing word processor documents written in different formats and many other variable types. For variable types centered around external/underlying documents, the full value is displayed by activating a process resulting in the document being viewed/represented and being editable in its native application on a separated but possibly overlying area, from the cell format of the display device or on a device determined by its native application. Methods for activating a document in its native application are well known in the field and are usually restricted by the operating system and the native application itself. For other types such as text and numbers the fill value is simply showing available details, determined using the value array, in a way which is not restricted, for ex. by size, by the cell format. Accordingly, since viewing the full value is restricted by the capabilities of the operating system and other applications, not all types are necessarily displayed using full value as indicated by (1202) in the flow chart. In the preferred embodiment, a list of methods for displaying the full value is available and searched (1203) and the corresponding method activated (1204) to display the full value of a variable/cell.
FIG. 13 shows a schematic block diagram. FIG. 13 gives an overview of the duality between a text and cell format and explains the above methods further. Program statements written in text, or equivalent, format are denoted by blocks numbered 1301 and 1303. A statement written in a functional language can be considered to be an assignment y=f(x) where y is the resulting variable, x represents the statement input variables and f represents the statement as defined by the programming language. Variable y has a variable name and a type definition as shown in box 1301. The statement f(x) is represented in box 1303. Associated to text, or equivalent, format 1301 is an editing mechanism as shown. Translation mechanism described by flow charts 1001, 1101 translate between the two formats. In cell format 1302 the variable y is assigned a cell and the variable—and cell name, also representing the cell location as is standard for spreadsheet environments, are equated and thus refer to the same variable y. The statement text, or equivalent, f(x) is assigned to the cell and can thus be edited by allowing the user to select the cell for editing its contents as is standard with spreadsheet environments. A change in the cell contents results in a changed definition for the corresponding module. A cell in cell format (1302) is assigned a value array to store information including results of program execution as determined by a system (1306) capable of parsing and compiling module definitions (1304), stored in memory 102 and in storage devices 103, into an executable code. Module definitions 1304 are stored in multiple formats including graphical specifications (e.g. 405) and on cell or text format. A change in a value array triggered by system 1306 triggers a change in how the cell is displayed as explained in flow chart 901 and indicated by line 1307 in the diagram. System 1306 is responsible for displaying the full value of a value array as described by flow chart 1201 and explained above. Changes in cell display are triggered by changes in module definitions 1304 which includes changes in cells being edited as indicated by line 1305.
FIG. 14 shows how, in a preferred embodiment, module definitions are used with traditional form designing environments and other application development systems. Forms provide an alternative format for working with modules designed by using the above methods. Module definitions are exported (1404) by an exporting mechanism (1403) into a format defined by an application environment (1405) being exported to allowing environment 1405 to access a module as a function with input values 203 and return values 204. Exporting mechanisms are well known in the art. In a preferred embodiment, a collection of methods for a predefined set of application environments and operating systems is available defining the export mechanism 1403. Exporting of modules is controlled by users of the embodiment. In a preferred embodiment, a form design and implementation mechanism (1401) is available to users allowing users to create alternative display formats in accordance with the design guidelines specified by a predefined list of operating environments. Design mechanism 1401 is capable of accessing and using (1402) module definitions 1304 directly without using an export mechanism by considering modules as functions with input—and return values.
The invention being thus described, it will become obvious that the same may be varied in many ways. Such variations are not to be regarded as a departure from the spirit and scope of the invention, and all such modifications as would be obvious to one skilled in the art are intended to be included within the scope of the following claims.
Claims (11)
Priority Applications (6)
|Application Number
|Priority Date
|Filing Date
|US39216495A true
|PCT/DK1996/000080 WO1996026484A2 (en)
|Graphical environment for managing and developing applications
|US08/690,919 US6286017B1 (en)
|Graphical environment for managing and developing applications
|US09/781,294 US6763498B2 (en)
|Graphical environment for managing and developing applications
Applications Claiming Priority (3)
|Application Number
|Priority Date
|Filing Date
|US09/781,294 US6763498B2 (en)
|Graphical environment for managing and developing applications
|US10/857,929 US7853867B2 (en)
|Modular application development in a spreadsheet using indication values
|US12/805,643 US20110022939A1 (en)
|Structure oriented graphical patchwork application environment
Related Parent Applications (1)
|Application Number
|Priority Date
|Filing Date
|US08/690,919 Division US6286017B1 (en)
|Graphical environment for managing and developing applications
Related Child Applications (1)
|Application Number
|Priority Date
|Filing Date
|US10/857,929 Continuation US7853867B2 (en)
|Modular application development in a spreadsheet using indication values
Publications (2)
|Publication Number
|Publication Date
|US20020010713A1 US20020010713A1 (en)
|US6763498B2 true US6763498B2 (en)
Family Applications (4)
|Application Number
|Priority Date
|Filing Date
|US08/690,919 Expired - Lifetime US6286017B1 (en)
|Graphical environment for managing and developing applications
|US09/781,294 Expired - Lifetime US6763498B2 (en)
|Graphical environment for managing and developing applications
|US10/857,929 Expired - Fee Related US7853867B2 (en)
|Modular application development in a spreadsheet using indication values
|US12/805,643 Abandoned US20110022939A1 (en)
|Structure oriented graphical patchwork application environment
Family Applications Before (1)
|Application Number
|Priority Date
|Filing Date
|US08/690,919 Expired - Lifetime US6286017B1 (en)
|Graphical environment for managing and developing applications
Family Applications After (2)
|Application Number
|Priority Date
|Filing Date
|US10/857,929 Expired - Fee Related US7853867B2 (en)
|Modular application development in a spreadsheet using indication values
|US12/805,643 Abandoned US20110022939A1 (en)
|Structure oriented graphical patchwork application environment
Country Status (6)
|US6286017B1 (en)
|EP0811193B1 (en)
|AU4783796A (en)
|CA2214972C (en)
|DE69600794D1 (en)
|WO1996026484A2 (en)
Cited By (7)
|Publication number
|Priority date
|Publication date
|US20030149708A1 (en) *
|Tsao Sheng A.
|Data object oriented repository system
|US20080183765A1 (en) *
|Microsoft Corporation
|Multisource composable projection of text
|US20090307278A1 (en) *
|Zack Grossbart
|Mechanisms to support object-oriented version control operations
|US20110225489A1 (en) *
|Charles Simonyi
|Domain transformation languages
|US8429525B2 (en)
|International Software Corporation
|Method and system for reversible design tree transformations
|US9782005B2 (en)
|Stryker Corporation
|Medical support apparatus
|US10095482B2 (en)
|Mastercard International Incorporated
|Systems, methods, and media for graphical task creation
Families Citing this family (97)
|Publication number
|Priority date
|Publication date
|US6911987B1 (en) *
|Microsoft Corporation
|Method and system for transmitting data for a shared application
|US5847953A (en) *
|National Instruments Corporation
|System and method for performing class checking of objects in a graphical data flow program
|US5995918A (en) *
|Unisys Corporation
|System and method for creating a language grammar using a spreadsheet or table interface
|AU6252399A (en) *
|I2 Technologies, Inc.
|System and method for displaying logistics information associated with a supply chain
|JP2002531890A (en) *
|シーベル システムズ,インコーポレイティド
|Development tools, methods and systems in a client-server application
|US6542880B2 (en) *
|Indeliq, Inc.
|System, method and article of manufacture for a goal based system utilizing a table based architecture
|US6782374B2 (en) *
|Accenture Global Services Gmbh
|System, method and article of manufacturing for a runtime program analysis tool for a simulation engine
|US6369836B1 (en) *
|Cause effect diagram program
|US6389587B1 (en) *
|Sun Microsystems, Inc.
|User interface for developing and executing data flow programs and methods, apparatus, and articles of manufacture for optimizing the execution of data flow programs
|US6434523B1 (en) *
|Nuance Communications
|Creating and editing grammars for speech recognition graphically
|FR2793912B1 (en) *
|Crouzet Automatismes
|universal tool graphs compilation
|US6600497B1 (en) *
|Elliot A. Gottfurcht
|Apparatus and method to navigate interactive television using unique inputs with a remote control
|GB2356946B (en) *
|Fujitsu Serv Ltd
|Computer system user interface design
|GB2360367B (en) *
|A configurable framework for composition of connected entities in an application or logic sequence
|US6782528B1 (en) *
|International Business Machines Corporation
|Method and system for visual programming using a relational diagram
|AUPQ966400A0 (en) *
|Xemplex Pty Ltd
|Method of graphically defining a formula
|US7219307B2 (en)
|Jpmorgan Chase Bank
|Methods for graphically representing interactions among entities
|DE10106639A1 (en) *
|Karlsruhe Forschzent
|Procedures for coupling of physical and geometric calculation programs with a data processing system
|US7117430B2 (en) *
|Microsoft Corporation
|Spreadsheet error checker
|US7051319B1 (en)
|Siebel Systems, Inc.
|Method, system, and product for upgrading software objects using inherency
|US20020194217A1 (en) *
|International Business Machnies Corporation
|Metadata graphial user interface
|US6668529B2 (en) *
|Emark Manufacturing Company, Incorporated
|Operator control system for self-propelled vehicles
|US20030054806A1 (en) *
|Raymond Ho
|System and method for defining, creating and deploying wireless applications
|US7010779B2 (en) *
|Knowledge Dynamics, Inc.
|Parser, code generator, and data calculation and transformation engine for spreadsheet calculations
|EP1430389A4 (en) *
|Efunds Corp
|Method and apparatus for formatting a data grid for the display of a view
|DE10147341B4 (en) *
|Voiceobjects Ag
|Method and apparatus for constructing a computer system implemented in a dialog control of dialogue objects and associated computer system for performing a dialogue control
|US20030160831A1 (en) *
|International Business Machines Corporation
|System for indicating the stability of application programs through indicators associated with icons representing the programs in the graphical user interface of a computer controlled display
|US20050177816A1 (en) *
|National Instruments Corporation
|Automatic generation of graphical program code for a graphical program based on the target platform of the graphical program
|US7418664B2 (en) *
|Microsoft Corporation
|Application sharing single document sharing
|US7028266B2 (en) *
|Microsoft Corporation
|Processing occluded windows during application sharing
|US7293243B1 (en)
|Microsoft Corporation
|Application sharing viewer presentation
|US20060095838A1 (en) *
|Truc Nguyen
|Object-oriented processing of tab text
|US7356563B1 (en)
|Microsoft Corporation
|Methods of annotating a collaborative application display
|US7028222B2 (en) *
|National Instruments Corporation
|Target device-specific syntax and semantic analysis for a graphical program
|US20040019848A1 (en) *
|Truc Nguyen
|Method for dynamically inserting and removing tab text
|US7117449B1 (en)
|Siebel Systems, Inc.
|Method and apparatus to present an integrated process modeler
|US20040143812A1 (en) *
|Vladimir Bernstein
|Automatic software design tool for building web and other applications wherein components are linked through connected command and control and data variables
|US7237226B2 (en) *
|Intentional Software Corporation
|Method and system for storing pending changes to data
|US7165238B2 (en) *
|Intentional Software Corporation
|Method and system for organizing and manipulating nodes by category in a program tree
|US7433878B2 (en) *
|American Express Travel Related Services Company, Inc.
|Method and system for interfacing with accounting systems
|US7761847B2 (en) *
|National Instruments Corporation
|Timed sequence for a graphical program
|US7703034B2 (en) *
|National Instruments Corporation
|Visualization tool for viewing timing information for a graphical program
|US20050081141A1 (en) *
|Einfalt Ehf.
|Visual programming system and method
|US7725712B2 (en) *
|Syferlock Technology Corporation
|User authentication system and method
|DE102004007638A1 (en) *
|Xapio Gmbh
|A method for generating source code in a procedural, programming reentrantfähigen from a spreadsheet representation
|US8661332B2 (en)
|Microsoft Corporation
|Method and apparatus for document processing
|US7383500B2 (en)
|Microsoft Corporation
|Methods and systems for building packages that contain pre-paginated documents
|US7617450B2 (en) *
|Microsoft Corporation
|Method, system, and computer-readable medium for creating, inserting, and reusing document parts in an electronic document
|US7716231B2 (en) *
|Microsoft Corporation
|System and method for generating suggested alternatives for visual or audible submissions
|US7647551B2 (en) *
|Microsoft Corporation
|System and method for formatting a cell in response to data stored in a separate location
|US7620889B2 (en) *
|Microsoft Corporation
|Method and system for linking data ranges of a computer-generated document with associated extensible markup language elements
|US7617444B2 (en) *
|Microsoft Corporation
|File formats, methods, and computer program products for representing workbooks
|US7617451B2 (en) *
|Microsoft Corporation
|Structuring data for word processing documents
|US7752632B2 (en)
|Microsoft Corporation
|Method and system for exposing nested data in a computer-generated document in a transparent manner
|US7770180B2 (en)
|Microsoft Corporation
|Exposing embedded data in a computer-generated document
|CA2614059C (en) *
|Orangescape Technologies Limited
|A system and method of defining a hierarchical datamodel and related computation and instruction rules using spreadsheet like user interface
|US20060224946A1 (en) *
|International Business Machines Corporation
|Spreadsheet programming
|US7596577B2 (en) *
|Microsoft Corporation
|Methods and systems for specifying a user interface for an application
|US8601383B2 (en)
|Microsoft Corporation
|User interface for creating a spreadsheet data summary table
|US8095866B2 (en)
|Microsoft Corporation
|Filtering user interface for a data summary table
|US7627812B2 (en) *
|Microsoft Corporation
|Variable formatting of cells
|SG133421A1 (en) *
|Singapore Tech Dynamics Pte
|Method and apparatus for an algorithm development environment for solving a class of real-life combinatorial optimization problems
|US7770100B2 (en) *
|Microsoft Corporation
|Dynamic thresholds for conditional formats
|US20080046861A1 (en) *
|Grieser Maria A
|Method and interface for creating a workbook to implement a business process
|US7949993B2 (en) *
|International Business Machines Corporation
|Method and system for providing a visual context for software development processes
|CN101617328A (en) *
|Method and apparatus for automatic configuration of meta-heuristic algorithms in a problem solving environment
|US20080186315A1 (en) *
|Nicolas Bissantz
|Method and system for providing sound information to a user
|US20080215959A1 (en) *
|Lection David B
|Method and system for generating a media stream in a media spreadsheet
|US20090089653A1 (en) *
|Microsoft Corporation
|Auto-generation and syndication of tables as forms
|US8407668B2 (en) *
|Microsoft Corporation
|Model based spreadsheet scripting language
|US20090158139A1 (en) *
|Morris Robert P
|Methods And Systems For Generating A Markup-Language-Based Resource From A Media Spreadsheet
|US20090164880A1 (en) *
|Lection David B
|Methods And Systems For Generating A Media Stream Expression For Association With A Cell Of An Electronic Spreadsheet
|US8069190B2 (en) *
|Cloudscale, Inc.
|System and methodology for parallel stream processing
|US8539443B2 (en) *
|National Instruments Corporation
|Edit time analyzer in a loosely typed textual language
|US8411085B2 (en)
|Microsoft Corporation
|Constructing view compositions for domain-specific environments
|US8620635B2 (en)
|Microsoft Corporation
|Composition of analytics models
|US8314793B2 (en)
|Microsoft Corporation
|Implied analytical reasoning and computation
|US8479156B2 (en) *
|National Instruments Corporation
|Providing target specific information for textual code at edit time
|US8493406B2 (en)
|Microsoft Corporation
|Creating new charts and data visualizations
|US8531451B2 (en)
|Microsoft Corporation
|Data-driven visualization transformation
|US8788574B2 (en)
|Microsoft Corporation
|Data-driven visualization of pseudo-infinite scenes
|US8866818B2 (en)
|Microsoft Corporation
|Composing shapes and data series in geometries
|US9330503B2 (en)
|Microsoft Technology Licensing, Llc
|Presaging and surfacing interactivity within data visualizations
|US8692826B2 (en)
|Brian C. Beckman
|Solver-based visualization framework
|US8352397B2 (en)
|Microsoft Corporation
|Dependency graph in data-driven model
|US20120192013A1 (en) *
|Certon Software Inc.
|Verification of Signal Processing Using Intelligent Points
|US8990675B2 (en) *
|Microsoft Technology Licensing, Llc
|Automatic relationship detection for spreadsheet data items
|US20140310619A1 (en) *
|Microsoft Corporation
|Signal capture controls in recalculation user interface
|US20140359417A1 (en) *
|Omer Bar-On
|Systems and methods for graphically modulating structured data
|CA2917304A1 (en) *
|Stamicarbon B.V.
|Removal of dust in urea finishing
|US9411562B2 (en) *
|Oracle International Corporation
|Inter-application transform builder for cloud applications
|GB2528452A (en) *
|Aptitude Software Ltd
|Rules editor
|US9990350B2 (en)
|Microsoft Technology Licensing, Llc
|Videos associated with cells in spreadsheets
|US20170124041A1 (en)
|Microsoft Technology Licensing, Llc
|Operations on images associated with cells in spreadsheets
|US10114617B2 (en)
|At&T Intellectual Property I, L.P.
|Rapid visualization rendering package for statistical programming language
|KR101669467B1 (en) *
|System for Non-developer centric application platform
|US10311217B2 (en) *
|Microsoft Technology Licensing, Llc
|Application piracy prevention with secure enclave protection of automatically modularized functions
Citations (19)
|Publication number
|Priority date
|Publication date
|US4901221A (en)
|National Instruments, Inc.
|Graphical system for modelling a process and associated method
|US4914568A (en)
|National Instruments, Inc.
|Graphical system for modelling a process and associated method
|US4956773A (en)
|Hitachi, Ltd.
|System and method of generating a source program from inputted schematic information
|US5021973A (en)
|International Business Machines Corporation
|Method for assisting the operator of an interactive data processing system to enter data directly into a selected cell of a spreadsheet
|US5033009A (en)
|Dubnoff Steven J
|System for generating worksheet files for electronic spreadsheets
|US5093907A (en)
|Axa Corporation
|Graphic file directory and spreadsheet
|US5182793A (en)
|Texas Instruments Incorporated
|Computer-aided decision making with a symbolic spreadsheet
|US5255363A (en)
|Mentor Graphics Corporation
|Graph-based programming system and associated method
|US5317686A (en)
|Lotus Development Corporation
|Data processing apparatus and method for a reformattable multidimensional spreadsheet
|US5428712A (en)
|Quantum Development Corporation
|System and method for representing and solving numeric and symbolic problems
|US5551041A (en) *
|Hewlett-Packard Company
|Wait for service request in an iconic programming system
|US5623592A (en) *
|Molecular Dynamics
|Method and apparatus for constructing an iconic sequence to operate external devices
|US5625823A (en) *
|Debenedictis; Erik P.
|Method and apparatus for controlling connected computers without programming
|US5680557A (en)
|The United States Of America As Represented By The Secretary Of The Army
|Natural computing system
|US5799295A (en)
|Kabushiki Kaisha Toshiba
|Constraint-based spreadsheet system capable of displaying a process of execution of programs
|US6113649A (en) *
|International Business Machines Corporation
|Object representation of program and script components
|US6154875A (en) *
|Fujitsu Limited
|Graphical programming system that allows easy handling of data structures and creation of programs by manipulating graphic components
|US6182160B1 (en) *
|Microsoft Corporation
|Method and system for using editor objects to connect components
|US6334211B1 (en) *
|Hitachi, Ltd.
|Method for visual programming with aid of animation
Family Cites Families (10)
|Publication number
|Priority date
|Publication date
|US4956733A (en) *
|Tandon Corporation
|Storage media transducer loading/unloading and carriage lock mechanism
|US5319777A (en) *
|Sinper Corporation
|System and method for storing and retrieving information from a multidimensional array
|US5361393A (en) *
|Prodigy Services Company
|Method for improving interactive-screen uploading of accounting data
|US5485600A (en) *
|Virtual Prototypes, Inc.
|Computer modelling system and method for specifying the behavior of graphical operator interfaces
|US5437006A (en) *
|Microsoft Corporation
|Spreadsheet command/function capability from a dynamic-link library
|US5632009A (en) *
|Xerox Corporation
|Method and system for producing a table image showing indirect data representations
|US5485617A (en) *
|Microsoft Corporation
|Method and system for dynamically generating object connections
|US5481715A (en) *
|Sun Microsystems, Inc.
|Method and apparatus for delegated communications in a computer system using trusted deputies
|US5729745A (en) *
|Microsoft Corporation
|Methods and apparatus for creating a base class for manipulating external data connections in a computer generated document
|US5768158A (en) *
|Inventure America Inc.
|Computer-based system and method for data processing
- 1996-02-22 DE DE1996600794 patent/DE69600794D1/en not_active Expired - Fee Related
- 1996-02-22 DE DE1996600794 patent/DE69600794T2/en not_active Expired - Lifetime
- 1996-02-22 WO PCT/DK1996/000080 patent/WO1996026484A2/en active IP Right Grant
- 1996-02-22 CA CA 2214972 patent/CA2214972C/en not_active Expired - Lifetime
- 1996-02-22 EP EP19960903932 patent/EP0811193B1/en not_active Expired - Lifetime
- 1996-02-22 AU AU47837/96A patent/AU4783796A/en not_active Abandoned
- 1996-08-01 US US08/690,919 patent/US6286017B1/en not_active Expired - Lifetime
- 2001-02-13 US US09/781,294 patent/US6763498B2/en not_active Expired - Lifetime
- 2004-06-02 US US10/857,929 patent/US7853867B2/en not_active Expired - Fee Related
- 2010-08-11 US US12/805,643 patent/US20110022939A1/en not_active Abandoned
Patent Citations (19)
|Publication number
|Priority date
|Publication date
|US4956773A (en)
|Hitachi, Ltd.
|System and method of generating a source program from inputted schematic information
|US5021973A (en)
|International Business Machines Corporation
|Method for assisting the operator of an interactive data processing system to enter data directly into a selected cell of a spreadsheet
|US4901221A (en)
|National Instruments, Inc.
|Graphical system for modelling a process and associated method
|US4914568A (en)
|National Instruments, Inc.
|Graphical system for modelling a process and associated method
|US5033009A (en)
|Dubnoff Steven J
|System for generating worksheet files for electronic spreadsheets
|US5182793A (en)
|Texas Instruments Incorporated
|Computer-aided decision making with a symbolic spreadsheet
|US5093907A (en)
|Axa Corporation
|Graphic file directory and spreadsheet
|US6334211B1 (en) *
|Hitachi, Ltd.
|Method for visual programming with aid of animation
|US5551041A (en) *
|Hewlett-Packard Company
|Wait for service request in an iconic programming system
|US5255363A (en)
|Mentor Graphics Corporation
|Graph-based programming system and associated method
|US5428712A (en)
|Quantum Development Corporation
|System and method for representing and solving numeric and symbolic problems
|US5317686A (en)
|Lotus Development Corporation
|Data processing apparatus and method for a reformattable multidimensional spreadsheet
|US6182160B1 (en) *
|Microsoft Corporation
|Method and system for using editor objects to connect components
|US6154875A (en) *
|Fujitsu Limited
|Graphical programming system that allows easy handling of data structures and creation of programs by manipulating graphic components
|US5799295A (en)
|Kabushiki Kaisha Toshiba
|Constraint-based spreadsheet system capable of displaying a process of execution of programs
|US5680557A (en)
|The United States Of America As Represented By The Secretary Of The Army
|Natural computing system
|US5625823A (en) *
|Debenedictis; Erik P.
|Method and apparatus for controlling connected computers without programming
|US5623592A (en) *
|Molecular Dynamics
|Method and apparatus for constructing an iconic sequence to operate external devices
|US6113649A (en) *
|International Business Machines Corporation
|Object representation of program and script components
Cited By (12)
|Publication number
|Priority date
|Publication date
|US20030149708A1 (en) *
|Tsao Sheng A.
|Data object oriented repository system
|US7376895B2 (en) *
|Wuxi Evermore Software, Inc.
|Data object oriented repository system
|US8429525B2 (en)
|International Software Corporation
|Method and system for reversible design tree transformations
|US9158507B2 (en)
|Intentional Software Corporation
|Domain transformation languages
|US20110225489A1 (en) *
|Charles Simonyi
|Domain transformation languages
|US7675527B2 (en)
|Microsoft Corp.
|Multisource composable projection of text
|US20080183765A1 (en) *
|Microsoft Corporation
|Multisource composable projection of text
|US8055619B2 (en) *
|Novell, Inc.
|Mechanisms to support object-oriented version control operations
|US8429142B2 (en)
|Novell, Inc.
|Mechanisms to support object-oriented version control operations
|US20090307278A1 (en) *
|Zack Grossbart
|Mechanisms to support object-oriented version control operations
|US9782005B2 (en)
|Stryker Corporation
|Medical support apparatus
|US10095482B2 (en)
|Mastercard International Incorporated
|Systems, methods, and media for graphical task creation
Also Published As
|Publication number
|Publication date
|WO1996026484A3 (en)
|WO1996026484A2 (en)
|DE69600794T2 (en)
|EP0811193A2 (en)
|US20040225957A1 (en)
|DE69600794D1 (en)
|AU4783796A (en)
|EP0811193B1 (en)
|US20020010713A1 (en)
|US6286017B1 (en)
|US20110022939A1 (en)
|CA2214972A1 (en)
|CA2214972C (en)
|US7853867B2 (en)
Similar Documents
|Publication Date
|Habermann et al.
|Gandalf: Software development environments
|Anderson et al.
|Chimera: Hypertext for heterogeneous software environments
|US7458062B2 (en)
|Framework to access a remote system from an integrated development environment
|US6502233B1 (en)
|Automated help system for reference information
|US6263492B1 (en)
|Run time object layout model with object type that differs from the derived object type in the class structure at design time and the ability to store the optimized run time object layout model
|US9268467B2 (en)
|Internet interface and integration language system and method
|US7114149B2 (en)
|Navigation links in generated documentation
|CA2704252C (en)
|System and process for interacting with a user to define a behavior of a portion of an interactive presentation
|US6102967A (en)
|Testing a help system of a computer software application without executing the computer software application
|US7043716B2 (en)
|System and method for multiple level architecture by use of abstract application notation
|JP4140980B2 (en)
|Display method that does not depend on the syntax of the computer program that displays the program tree
|US7039875B2 (en)
|Computer user interfaces that are generated as needed
|US6282699B1 (en)
|Code node for a graphical programming system which invokes execution of textual code
|US5768564A (en)
|Method and apparatus for translating source code from one high-level computer language to another
|US7412658B2 (en)
|Modeling system for graphic user interface
|CN101617292B (en)
|Producer graph oriented programming and execution
|AU733773B2 (en)
|Method and system for database application software creation requiring minimal programming
|US7272819B2 (en)
|Configuration model for configuring an adapter software component to selectively access software objects and object editor using instance of same
|US5761656A (en)
|Interaction between databases and graphical user interfaces
|US6243709B1 (en)
|Method and apparatus for loading stored procedures in a database corresponding to object-oriented data dependencies
|US7266565B2 (en)
|Table-oriented application development environment
|US7913170B2 (en)
|System and method for performing type checking for hardware device nodes in a graphical program
|EP0693193B1 (en)
|Incremental linker system
|US7681119B2 (en)
|Method and apparatus for providing a graphical user interface for creating and editing a mapping of a first structural description to a second structural description
|US6704743B1 (en)
|Selective inheritance of object parameters in object-oriented computer environment
Legal Events
|Information on status: patent grant
Free format text: PATENTED CASE
|Certificate of correction
|Fee payment
Year of fee payment: 4
|Fee payment
Year of fee payment: 8
Owner name: QZR IP HOLDINGS, LLC, CALIFORNIA
Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:EGILSSON, AGUST SVERRIR;REEL/FRAME:027355/0004
Effective date: 20111115
Owner name: SPYSCREEN LIMITED LIABILITY COMPANY, DELAWARE
Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:QZR IP HOLDINGS, LLC;REEL/FRAME:027354/0989
Effective date: 20111007
|Fee payment
Year of fee payment: 12
Owner name: GULA CONSULTING LIMITED LIABILITY COMPANY, DELAWAR
Free format text: MERGER;ASSIGNOR:SPYSCREEN LIMITED LIABILITY COMPANY;REEL/FRAME:037561/0508
Effective date: 20150826

subset: commoncrawl


text:
Arrests made as Cameroon elephant poaching crisis spreads
Posted on 28 March 2012
Twelve suspected poachers have been arrested and 14 elephant tusks confiscated outside protected areas in southeast Cameroon this week. Forest rangers carried out the arrests and seizures near Boumba-Bek and Nki National Parks after receiving intelligence information from village monitoring groups formed by WWF.Twelve suspected poachers have been arrested and 14 elephant tusks confiscated outside protected areas in southeast Cameroon this week. Forest rangers carried out the arrests and seizures near Boumba-Bek and Nki National Parks after receiving intelligence information from village monitoring groups formed by WWF.
The anti-poaching operation comes just weeks after the Cameroon military entered a national park in the North Region of the country where poachers have slaughtered hundreds of elephants since January. Up to 12,000 elephants are killed each year for their ivory, most in Central Africa.
In southeast Cameroon, rangers confiscated six firearms and 30kg of elephant meat in the joint anti-poaching operation that involved rangers from both national parks. Two other suspects are said to be on the run. The confiscated tusks are being kept under seal while the detained suspects await trial.
Constant threatThe adjoining national parks of Boumba-Bek and Nki are home an estimated 4,000 forest elephants according to a 2006 survey carried out by WWF. But elephants in these protected areas are under constant pressure from poachers from within Cameroon as well as from neighbouring Congo Brazzaville.
Achille Mengamenya, Park Warden of Boumba-Bek, says the poaching suspects have been operating in the area for a year and have evaded arrest several times in the past. "Preliminary investigations show this group of poachers has very strong links with a sister group based in Souanke, Congo Brazzaville. But they poach elephants mostly in Nki National Park," Achille said.
"With the connivance of some local people ivory is surreptitiously transported through the towns of Messok and Lomie in the East Region of Cameroon to Douala," the park warden said. "Four poachers, who were arrested in December 2011 with 44 ivory tusks near Lobéké National Park, also attested to having links with accomplices in Souanke. It is clear that the fight against poaching in the border areas between Cameroon, Congo and Central African Republic has to be stepped up to save what is left of elephants in the region."
International linksThose suspected of killing hundreds of elephants in North Cameroon's Bouba N'Djida National Park are believed to be foreigners who entered the country illegally across its border with Chad. Following that incident, WWF urged the Cameroon government to secure its borders, reinforce anti-poaching efforts, and ensure that suspects are tried and punished according to the law.
"After the international outcry of the Bouba N'Djida massacre it is time to put a stop to this senseless commercially motivated slaughter of Africa's biodiversity," says David Hoyle, Conservation Director for WWF Cameroon.
"Back in 2010, Jim Leape, Director General of WWF International, wrote a letter to the prime minister of Cameroon, drawing attention to the upsurge of elephant poaching using war arms in Southeast Cameroon," said Natasha Kofoworola Quist, WWF's Central African Regional Programme Office Representative. "The recent gruesome massacre of elephants in Bouba N'Djida in the north of the country in the space of two months shows the rapidity in the decimation of elephant population in Cameroon."
Global response"We hope to see stronger local and regional approaches and collaborative platforms to combat wildlife poaching and ivory trafficking in Central Africa. WWF is urging all participants who will be attending the Regional Workshop on Wildlife Trafficking and Dismantling Transnational Illicit Networks billed for Libreville, Gabon on April 3-5 to come out with concrete and realistic resolutions that could be implemented immediately to halt the carnage," Kofoworola Quist said.
In a letter to Cameroon President Paul Biya, European Parliament member Catherine Bearder highlighted the severity and scope of ivory poaching and offered the assistance of the European Union. "It is clear that illegal wildlife trade is not a small scale, local issue, but a major, organised transnational crime that threatens not only Africa's wildlife, but the security of its borders, its people and its reputation," Bearder wrote. "It is important to engage with the Heads of State in Chad and Sudan to launch a full response to this issue that will reassure the global community that these trans-national criminal acts are taken seriously," she said.
WWF has been providing critical support to Cameroon's Ministry of Forestry and Wildlife to combat poaching, especially ivory trafficking, in the southeast of the country for over 12 years. Logistics and financial support have been provided to hire, equip and train rangers, while buttressing field anti-poaching operations.


text:
Emma Stone & Halle Berry do a Cancer PSA with Revlon
The women of Revlon have never been quiet about their support of cancer-fighting causes, and now, they're coming together for the beauty brand's first-ever public service announcement campaign, created with the Entertainment Industry Foundation.
Halle Berry and Emma Stone star in the stark clip, which focuses on the message that "Your Lips Can Save Lives" when you talk about cancer and encourage loved ones to schedule regular medical check-ups to ensure early detection.
"We sort of did a play on how we can use our lips, while wearing lipstick, to laugh, to flirt and to spread the word about cancer, and encourage other women to do the same," Berry says in a release.
"We can talk to the women that we love about getting screened today," Stone adds.
Since 1990, Revlon has raised more than $75 million for cancer-fighting causes through fundraising efforts that include its annual EIF Revlon Run/Walk for Women. In addition to the PSA, out this week, the brand is also running a print campaign, which features Stone and her mother, a breast cancer survivor. Visit revloncares.com for more information, and to see how you can help.
Source 1 & 2


text:
WESTON, Mass. – In a game that featured six ties, men's lacrosse earned their second straight victory thanks in part to Noah Ellis (Hingham, Mass.) who scored two goals in the closing minutes to break a deadlock and come away with a 14-12 win against Regis College Thursday afternoon.
Not only did Ellis lift the Beacons to the non-conference victory, but they also saw junior John Powers (Marshfield, Mass.) unload a team-best six points (4g, 2a) to help even their record at 8-8. Regis College fell to 9-6 despite a seven point (4g, 3a) showing from the Pride's Peter Leighton.
The Pride got things started early by scoring back-to-back goals to take a 2-0 advantage by the 9:13 mark of the first quarter. The Beacons responded by notching three goals in less than three minutes to jump ahead for a 3-2 lead. Dom Fichera (Scituate, Mass.) beat the Regis goalie with a low shot after receiving a quick pass on the goal line from Ellis following unassisted goals by Tommy Petitti (Quincy, Mass.) and Donny Delpha (Walpole, Mass.).
Regis would score the final two goals of the opening quarter to take a slim 4-3 lead.
The Pride would score the first goal and the last goal of the second quarter, but three Beacon goals were sandwiched in between. After the opening goal, Ryan McGoff (Charlestown, Mass.) cut the deficit back to one on a pass from Delpha, and Powers scored two unanswered goals to reclaim the lead for Boston. Powers' tucked his second goal inside the post after receiving a pass in front from Nick Weiss (Westfield, Mass.).
Coming out of halftime, the Beacons made the most of their man-up opportunities and looked like they might run away with the game after Delpha, Powers, and Fichera each found the back of the net to push their lead to 9-6. The Pride answered back with a man-up goal of-their-own.
McGoff pushed the lead back to three by the 6:53 mark, but Regis scored three quick goals to close out the third quarter, including two in the last 30 seconds, to even the score at 10-10.
The back-and-forth action continued into the game's final stanza, as the Beacons opened up with two goals before the Pride came storming back with two of their own. Powers and Petitti capitalized for Boston before Regis answered back with a pair of goals.
With the game deadlocked at 12, Ellis provided the heroics for the Beacons by notching two goals with under four minutes to play to put the game away. The game-winner came with 3:40 to play when Ellis took a pass in front from Weiss and sent the ball top shelf. He added some insurance less than 60 seconds later when he shot the ball towards the opposite post after getting the ball from Powers.
Brendan Crane suffered the loss in goal despite a 16 save performance. A.J. Collette (W. Springfield, Mass.), Craig Frehill (Norwell, Mass.), and James Bischoff (East Lyme, Conn.) combined for 12 saves in the win for UMass Boston.
The Beacons wrap up their regular season schedule this Saturday with a 1 p.m. home game against UMass Dartmouth.
Information for this release provided by Regis College Sports Information Department