WO2015040536A1 - Hybrid software development - Google Patents

Abstract

A hybrid software development system can represent a program in various representations, including visual, e.g., graphical, representation and textual, e.g., source code, representation. The hybrid software development system can store the program in a structure storage for the target language, which can be viewed and edited by either textual or visual corresponding programming language. Mapping programs can be used to perform a conversion between a structure storage and any of the representations of the structural storage.

Description

Hybrid software development

Niklas Hofmann

This application claims priority from U.S. provisional patent application serial no.

61/879,122, filed on 9/17/2013, entitled "Hybrid software development", which is incorporated herein by reference.

The present invention relates to the field of computer systems and, in particular, to a programming language and system that can be represented in at least visual-based and text-based viewers.

Background

Nowadays textual representations are still the best way to express complex solutions, which is taken from the viewpoint of software developers, and not necessarily agreed to by other experts. Currently, most programming languages are purely textual. Some are visual. There are a few visual multi-paradigm languages with object-oriented features. Since a person has to choose between textual and visual representation when designing a programming language, visual programming languages are successful in specific problem domains only.

Fig. 1 illustrates a prior art approach for software development according to some embodiments. An expert 110, e.g., a person who is knowledgeable in conceptual and operating ideas, has an application concept that needs to be implemented. The expert 110 can contact and exchange information with a software developer 120, who can create a source code 130 representing a software program. In the process of creating the source code 130, the software developer 120 can require inputs from the expert, and then convert the inputs to the textual language of the source code 130. The source code represents computational logic and instructions using literal statements or text. After the source code 130 is written, it can be compiled to generate a machine language, byte code or other Turing complete language, or interpreted program 140, which can be executed by a data processing system, such as a computer. Textual representations can be difficult to visualize and follow, making the development of large scale programs difficult. Thus in general, the application concept can be developed by an expert, but the task of programming can be performed by a software developer. In this text-based programming environment, e.g., source code development by software developer, the role of the expert can be limited to the interaction with the software developer in provide guidance and direction.

To allow the expert to directly express the ideas and concepts in a programming environment, various graphical programming environments are provided. In the graphical programming environment,

the expert can construct a graphical program or graphical diagram. The graphical programming environment can allow the expert to easily and intuitively create a graphical program, without or with minimum knowledge of text-based programming, e.g., source code development. Usually, the graphical diagram can be used to generate source code, which then can be combined with manually crafted source code and get compiled to machine language or bytecode.

Fig. 2 illustrates another prior art approach for software development according to some embodiments. An expert 210 can create a graphical program 230 representing a software program. After the graphical program 230 is written, it can be used to generate a source code 235, which can be combined with manually- crafted source code 237, and then the combined source code can be compiled to generate a machine language program 240, which can be executed by a computer. Alternatively, the graphical program 230 can run without being compiled, e.g., interpreted, by the computer.

Graphical programming environments can address a need for programming by the experts. However, graphical programming environments are still not powerful enough to completely replace textual programming environments. For example, certain programs cannot be easily or successfully programmed with graphical programming environments, and can require the levels of complexity and thoroughness of textual programming environments.

It is therefore desirable to provide an improved programming language and system which can aid in the development of software, for example, a structure storage that can be represented in various textual and visual forms. Summary

In some embodiments, provided is a hybrid software development

model/system/environment that represents a program in various representations, including visual, e.g., graphical, representation and textual, e.g., source code, representation. With hybrid software development, a person does not have to decide whether to program in textual or visual form. The hybrid software development system can store the program in a structure storage for the target language, which can be viewed and edited by either textual or visual corresponding

programming language.

In some embodiments, there are methods and systems provided to allow a user to create, view, and edit a software program using various forms of representations, such as source codes in a textual programming environments, or graphical diagrams in a graphical programming environment. For example, a first user, e.g., an expert, can create a program using a graphical programming environment. A second user, e.g., a software developer, can open the program for editing and continuing the programming using a textual programming environment.

In some embodiments, provided is a structure storage of a software program that can be represented by different programming environments, such as a textual programming

environment and a graphical programming environment. The structure storage can include metadata of the program, such as data and commands so that a programming environment can interpret the structure storage in the language of that programming environment. For example, the structure storage can include data and commands to allow a conversion to a source code. In addition, the structure storage can include data and commands to allow a conversion to a graphical diagram.

In some embodiments, provided are mapping programs that can perform a conversion between a program, which is saved in a structure storage format, and its representations. The mapping programs can display a structure storage in different representations. Alternatively, the mapping programs can save a program, from various representations, to a structure storage. For example, a source code mapping program can read a structure storage and display a source code representation of the structure storage. A graphical mapping program can read the same structure storage and display a graphical diagram representation of the structure storage. In some embodiments, the mapping programs can be a full mapping program or a partially mapping program. For example, all data and commands in the structure storage can be mapped to the desired representation. Alternatively, only a portion of the data and commands can be mapped. Other portions can be ignored by the partially mapping program.

In some embodiments, provided is a virtual source code representation of a program. In one aspect, the virtual source code can behave like a source code, for example, to be edited by a software developer. The virtual source code can include tooltips that provides information about the object or code portion at the location of the cursor. The tooltip is a graphical user interface element used in conjunction with a cursor, in which a user hovers the cursor over an item, without clicking it, and a small "hover box" with information about the item being hovered over appears. The virtual code can include layers of information. For example, only a flow chart or a general overview of the program can be showed by the virtual source code. Other information can be additionally viewed, such as comment lines, computation details, or indexing information.

In some embodiments, the virtual source code can include information in layers. For example, a first layer can include information regarding the data flow of the program. A second layer can include information regarding the explanation of the written codes. A third layer can include the detailed computation of the program. A fourth layer can include information regarding the index of the program. A fifth layer can include information regarding the explanation and definition of the terms and objects in the program.

Brief description of the drawings

Fig. 1 illustrates a prior art approach for software development according to some embodiments.

Fig. 2 illustrates another prior art approach for software development according to some embodiments.

Fig. 3 illustrates a programming environment framework according to some

embodiments.

Fig. 4 illustrates a program stored as a structure storage together with its source code and graphic diagram representations according to some embodiments.

Fig. 5 illustrates another program stored as a structure storage together with its source code representation according to some embodiments. Fig. 6 illustrates another program stored as a structure storage together with its graphic diagram representation according to some embodiments.

Figs. 7 A - 7C illustrate flowcharts for storing a program in a structure storage format according to some embodiments.

Figs. 8A - 8C illustrate flowcharts for compiling a program having a structure storage format according to some embodiments.

Fig. 9 illustrates a flowchart for forming a program having a structure storage format according to some embodiments.

Fig. 10 illustrates a diagram showing different mappings for a program according to some embodiments.

Figs. 11 A - 1 IB illustrate flowcharts showing different mapping processes according to some embodiments.

Fig. 12 illustrates a layer representation of a program according to some embodiments. Fig. 13 illustrates a program showing one layer according to some embodiments.

Fig. 14 illustrates a program showing two layers according to some embodiments.

Fig. 15 illustrates a program showing two other layers according to some embodiments. Fig. 16 illustrates a program showing two other layers according to some embodiments. Fig. 17 illustrates a program showing a tooltip according to some embodiments.

Figs. 18A - 18D illustrate flowcharts for operating layered programs according to some embodiments.

Figs. 19A - 19D illustrates another flowchart for operating a layered program according to some embodiments.

Fig. 20 illustrates a computing environment according to some embodiments.

Fig. 21 is a schematic block diagram of a sample computing environment 2100 with which the present invention can interact.

Detailed description of the embodiments

In some embodiments, provided are programming methods and systems to generate at least text-based source code representation and graphic-based diagram representation. For example, a program can be accessed by a text editor, which can view the source code representation of the program, allowing editing and creating the program as a source code. The program can also be accessed by a visual graphic editor, which can view the graphic diagram representation of the program, allowing editing and creating the program as a graphic diagram. Other representations can also be included, such as combination representation of graphic and text.

In some embodiments, a program can be stored in a structure storage to allow the creation of different representations. The structure storage can include data (which contains information to describe the software program) and format (which contains metadata to describe possible representation associated with the structure storage type). For example, the structure storage can include information related to an object, together with instructions to generate a source code representing the object and instructions to generate a graphic diagram representing the object.

The multiple representations of the program can allow an expert, e.g., a person knowledgeable in his field, such as education or business, who is not a trained programmer, to transform his ideas into computer programs, for example, by programming in graphic-based editor through the graphic diagram representation. The multiple representations of the program can also allow a programmer, e.g., a software developer, to continue to create a program with the familiar source code editor, and at the same time, allowing the programmer to view the program in a more intuitive programming environment of graphic diagram editor, for example, to debug or to check the general program flow methodology. The multiple representations of the program can also allow collaboration of experts and programmers in programming environments. For example, an expert can start a program by expressing his idea through the graphic diagram editor. A programmer can continue, adding details and other provisions through the source code editor. The expert can check the programmer's effort by viewing the program through the graphic diagram editor. The expert can also continue to modify or extend the software.

Other representations can also be included. For example, the program can be stored in a structure storage format that also allow the program to be represented by a browser-side

JavaScript compliant language which can in turn be natively interpreted by browsers. A program can be written in a various representations, including high level languages to create web sites and applications that run natively in a browser, which can be compiled to a lower-level language. In some embodiments, provided is a programming model that can include a hybrid software development system, which can combine at least the power of source code and graphical representations. The combination of graphical and the textual representation (and optional any other form of representation) are always in sync. Depending on the programming language, this approach can allow experts to take part in the software implementation process directly and also can allow an extensive collaboration between experts and developers. For example, dataflow, data-oriented and business process applications are well suited using the hybrid software development model, but other type of software can also benefit from this model.

In some embodiments, the programs used in the hybrid software development model can be stored in a structure storage, which can include a structure storage format for describing the elements and their associations, together with structure storage data for containing the software program, e.g., the program structure in an object format. The structure storage can provide the data to the software itself or any other software during runtime, which allows the software to perform reflection in general, including online-migration of data stores without downtime (life migration). The structure storage can include versioning, allowing the tracking of changes. This can be equivalent to a version control system which knows about the structure of the content; therefore classical version control systems may not be needed, since classical version control systems do not know anything about the content they manage.

In some embodiments, the hybrid software development model can allow the

implementation and usage of various other types of mappings and editors/viewers, e.g. based on an audio interface to allow visually impaired people to develop software w/o the typical barriers.

Thus the multiple representation capability of a program, e.g., through a structure storage representation, can provide a programming environment to a wide range of persons, allowing them to transform ideas into programs without being programmers, and also allowing them to collaborate on the implementation level. The structure storage can include data and metadata for describing associations of the data in the representations. Different metadata can be included for the conversion and representation of the stored data to different representations.

Fig. 3 illustrates a programming environment framework according to some

embodiments. An expert 310 can incorporate his idea in a graphical editor (or viewer) 330, for example, to form a graphical diagram that is a representation of the program that is the embodiment of the idea. From the graphical editor, expert 310 can read and edit the graphical representation. The graphical diagram can be saved or updated to a structure storage 350. The structure storage 350 can include the data from the graphical diagram, together with commands and instructions to re-create the graphical diagram from the saved data.

The graphical editor can present a graphical representation of a program saved in a structure storage format. The graphical editor can usually be programming language

independent, but some special graphical editor can be programming language dependent. In some embodiments, a graphical editor can operate on the structure storage, e.g., the software program saved in a structure storage format. For example, the editor can allow modifying the program and re-saving it in the same structure storage. In some embodiments, the graphical editor can be only a read-only editor, such as a graphical viewer, e.g., allowing viewing the program without modification capability. The graphical viewer may not operate on the structure storage, e.g., the graphical viewer can operate on a copy of the structure storage without the ability to change the structure storage itself.

In some embodiments, the graphical editor can read the structure storage, and issue commands on-the-fly to the structure storage while expert/developer edits the graphical representation.

In some embodiments, a graphical structure mapping can be included to map the structure storage to the graphical representation, displayed by the graphical editor. The graphical editor can use the graphical structure mapping to display the data of the structure storage as graphic, to keep track of edits to translate them to commands for the structure storage, and to assist the user while editing. In some embodiments, the graphical structure mapping may be an inseparable part of the graphical editor.

In addition, equivalent commands and instructions to create a source code representation are also included in the structure storage 350. For example, templates from the graphical editor can include command and instructions to re-create the templates in different representations, such as graphical diagram representation and source code representation. Other representations can also be included, such as an audio based representation.

A software developer 320 can access the program, e.g., the structure storage 350 of the program, for example, through a source code editor 335. In some embodiments, the source code editor is called a virtual source code editor, which can operate on the structure storage. Thus the virtual source code editor can be different from a conventional source code editor which cannot operate on a structure storage. In addition, the virtual source code editor can have similar capability as the conventional source code editor, e.g., can operate on a text based source code.

The virtual source code editor can present a source code representation of a program saved in a structure storage format. The virtual source code editor can usually be programming language independent, but some special virtual source code editor can be programming language dependent. In some embodiments, a virtual source code editor can operates on the structure storage, e.g., the software program saved in a structure storage format. For example, the editor can allow modifying the program and re-saving it in the same structure storage. In some embodiments, the virtual source code editor can be only a read-only editor, such as a source code viewer, e.g., allowing viewing the program without modification capability. The viewer may not operate on the structure storage, e.g., the viewer can operate on a copy of the structure storage without the ability to change the structure storage itself.

In some embodiments, the virtual source code editor can read the structure storage, and issue commands on-the-fly to the structure storage while developer edits the virtual source code representation.

In some embodiments, a source code structure mapping can be include to map the structure storage to the source code representation, displayed by the virtual source code editor. The virtual source code editor can use the source code structure mapping to display the data of the structure storage as source code, to keep track of edits to translate them to commands for the structure storage, and to assist the user while editing. In some embodiments, the source code structure mapping may be an inseparable part of the virtual source code editor.

Since the structure storage 350 includes commands and instructions to display the source code representation of the program, the virtual source code editor 335 can read the structure storage 350 for the software developer 320. The software developer 320 can read and edit the source code representation, and continue the programming in his familiar programming environment of source code editor 335.

In addition, the software developer can access the program through the graphical editor 330, for example, to observe, debug, or formulate a general program flow. The developer can read and edit the graphical representation of the program, e.g., through the structure storage. Since the graphical representation and the source code representation are two different representations of the same structure storage, these two representations are always in

synchronization, and contain equivalent information and data.

At any point in the program development cycle, the expert 310 also can participate in the programming effort through the graphical editor 330. The expert and developer can also exchange information about the concept and the implementation of the software.

In some embodiments, the representations and editors of a structure storage is not limited to graphical representation/editor and source code representation/editor. Other representations and their associated editors can also included, such as an audio representation, together with an audio editor (including read-only editor or viewer), which can provide audio input and output, e.g., through synthesized voice, and voice recognition. The audio editor can be analogous to the graphical and the source code editor disclosed above.

In some embodiments, provided are structure storages and structure storage formats for software programs. The structure storage can contains data describing the software, e.g., storing a software, and storing the program structure in an object format. The structure storage can distinguish between entities with identity and values. The structure storage can be stored in versions, providing versioned storage copies.

In some embodiments, the structure storage can use a structure storage format to organize the data. The structure storage format and/or the mappings might be stored in the structure storage along with the data describing the software, allowing a representation editor to access the structure storage.

In some embodiments, the structure storage format can include meta data for describing the elements and their associations of the programming language. The structure storage format can be programming language dependent. For example, a structure storage format for C++ programming language can include meta data for translating the structure storage, e.g., the data stored in the structure storage format, into C++ objects and syntax, for example, when using a virtual source code mapping.

In some embodiments, mappings can be provided for mapping from a structure storage to a representation. A mapping can provide a mapping description for every element and association of the programming language or for a sub-set of elements and associations. When a mapping is used for editors, the mapping description can be either the identity-function, a distinct function or an arbitrary bijective function (backward and forward translation). When a mapping is used for viewers, read-only editor, the mapping description can be any arbitrary function.

For example, a source code mapping can be used to translate between a structure storage and a source code representation. The source code mapping can describe the mapping of elements of the structure storage format to source code elements. The source code mapping can be programming language dependent, and together with the language dependent meta data contained in the structure storage format, can reconstruct the structure storage into the source code representation. The source code mapping may be included in a source code editor, such as a virtual source code editor. The virtual source code editor can use the source code mapping to display the data of the structure storage as virtual source code, to keep track of edits to translate them to commands for the structure storage and to assist the user while editing.

A graphical structure mapping can be used to translate between a structure storage and a graphical representation. The graphical structure mapping can describe the mapping of elements of the structure storage format to graphical elements. The graphical structure mapping can be programming language dependent, and together with the language dependent meta data contained in the structure storage format, can reconstruct the structure storage into the graphical representation. The source code mapping may be included in a graphical editor. The graphical editor can use the graphical structure mapping to display the data of the structure storage as virtual source code, to keep track of edits to translate them to commands for the structure storage and to assist the user while editing.

Other structure mapping can be used, such as an audio mapping, translating a structure storage to audio output while accepting audio input, using synthesized voice and voice recognition.

After the program is complete, it can be compiled to machine language code or Bytecode or other Turing complete languages 340. The compiled program can be executed by a CPU (central processing unit), a virtual machine or an interpreter. The compiled program can run on a native platform (OS/Architecture) or in a web browser. For example, the structure storage can get translated to machine language, bytecode or other Turing complete languages either directly or in multiple steps using intermediate formats. The structure storage can also provide structure information about the software during runtime (runtime information, runtime type information), allowing reflection and online-migration without downtime.

Alternatively, the program can be interpreted, e.g., running from the structure storage without first being compiled. The program can be interpreted by an interpreter, which includes a software which interprets high-level structure data to run a software. The interpreter can run on a native platform (OS/Architecture) or in a web browser. For example, the interpreter executes the program stored in the structure storage.

In some embodiments, provided is a hybrid software development

model/system/environment that can represent a program in multiple representations, which can allow users without programming knowledge and software developers alike to create and develop simple custom applications as well as more substantial software.

The hybrid software development can encompass an application orientation feature, including all of the qualities related to this special form of software development. Even users without skills in software development can be able to create dataflow, data oriented or business process oriented applications efficiently. For example, the data structure just needs to be created with a graphical editor. It can then be used as a complete application based on a standard user interface. With more in-depth knowledge, this standard interface can be modified to meet individual requirements.

In addition, the hybrid software development is also aimed at advanced software developers, allowing them to create applications with the usual technical depth (similar to C++). Here, in addition to the highly integrated approach of the development, they also have a range of standard technologies available on demand, including Java, JVM, .NET, C, C++, HTML5, and JavaScript. By combining both development methods, users without software development skills can design applications in collaboration with software developers.

In some embodiments, the hybrid software development model/system/environment can be designed to meet actual requirements regarding the form of expression during the

development of applications. The development model/system/environment can remove the strict separation at the working level between software developers and problem domain experts for dataflow, data oriented or business process oriented applications and facilitates a unique form of collaboration between these specialized teams. Additionally, advanced users without

programming skills are able to work independently to create dataflow, data oriented or business process oriented applications in a short time and without complications. At the same time, it remains possible for software developers to expand the same applications at a later date without having to compromise on the level of technical depth that is usual in their profession. Further, the development model/system/environment can fully address both dataflow, data oriented or business process oriented and other applications, such as office software, computer games, and graphic design tools, and supports all of the above without limitation.

In some embodiments, software developers and users can access the same structural information relating to applications with a different level of detail and in various presentation formats. This is made possible by an approach that allows data generated by the user or the developer, e.g. data generated by using a virtual source code editor using a source code representation, to be immediately transferred and stored as structured information at any moment during the design of an application. This applies both to the development of data models using graphic design tools and to any work using a source code editor, which will only assume one of many possible functions of representation and is able to respond flexibly to accommodate the desired level of detail. For example, within the context of the hybrid software development model/system/environment, source code is no longer a necessity, but one of many possible forms of expression.

In some embodiments, provided are methods, and structure storages and structure storage formats generated from the methods, to store a program in two or more representations, such as source code representation, graphic diagram representation, or audio representation. For example, a software program can be stored in a structure storage format, to become a structure storage, so that the software program can be re-constructed in two or more different

representations.

In some embodiments, the structure storage can contain information to allow a source code editor to read the program, and then display the source code representation of the program. The structure storage can contain information to allow a graphic diagram editor to read the program, and then display the graphic diagram representation of the program. The structure storage can contain information to allow an audio editor to access the program, such as outputting and receiving input through an audio interface. In some embodiments, the structure storage can contain information to allow more than one editor to read and display the representations.

In some embodiments, the program can include equal representations, e.g., the graphic diagram representation containing the same information as the source code representation. In some embodiments, the program can include unequal representations, e.g., the graphic diagram representation containing less information than the source code representation. For example, the graphic diagram representation can be used to show the flow diagram of the program, while the source code representation can be used to show the details, including computations and comments.

In some embodiments, the structure storage can include meta data relating to the construction of the program in different representations. The structure storage can include meta data associated with respective levels of abstraction within the program hierarchy, which can be displayed by a graphical or textual programming interface. For example, the meta data can include commands, instructions and information to allow the construction of source code, graphic diagram, or other representations of different objects, of different computation methodologies, and of other elements of a software program.

In some embodiments, the meta data can include re-construction information related to object-oriented programming. For example, the meta data can specify the construction, for example, in source code representation and graphic diagram representation, a collection of objects, with each object having a block of instructions describing various procedures (e.g., methods), which are to be performed by the computer in response to various commands (e.g., messages) sent to the object.

In some embodiments, a source code representation includes a textual language, with variables for containing data, and keywords for specifying the actions of the program. Examples of the source code representation include textual programs written in Basic, Pascal, or C. A graphic diagram representation includes models or block diagrams, which include interconnected nodes or icons that visually indicate operation of the model or block diagram. Examples of the graphic diagram representation includes graphical programs written in Simulink, SystemBuild, VisSim, or Hypersignal Block Diagram. The source code or graphic diagram representations can include data structures and/or program instructions. The representations, e.g., these data structures and/or program instructions, can be compiled or interpreted to produce machine language, Bytecode or other Turing complete languages that a computer can run to accomplish the desired method or process as shown in the representations.

Fig. 4 illustrates a program stored as a structure storage together with its source code and graphic diagram representations according to some embodiments. A class object, named

Counter, is provided in a program. The Counter class can be stored as a structure storage 450, including data and meta data to allow the construction of two or more different representations. For example, a source code representation 435 can be generated from the structure storage 450, using the meta data as templates to construct the source code 435. The source code generation can be performed by a source code view or editor, mapping the structure storage 450 to the source code representation 435. In addition, a graphic diagram representation 430 can be generated from the structure storage 450, using the meta data as templates to construct the graphic diagram 430. The graphic diagram generation can be performed by a graphic diagram view or editor, mapping the structure storage 450 to the graphic diagram representation 430.

Fig. 5 illustrates another program stored as a structure storage together with its source code representation according to some embodiments. An activity of binary search is provided in a program. The activity can be stored as a structure storage 550, including data and meta data to allow the construction of two or more different representations. For example, a source code representation 535 can be generated from the structure storage 550, using the meta data as templates to construct the source code 535. The source code generation can be performed by a source code view or editor, mapping the structure storage 550 to the source code representation 535. After the source is modified, e.g., edited, the source code representation 535 can be saved or updated in the structure storage 550.

Fig. 6 illustrates another program stored as a structure storage together with its graphic diagram representation according to some embodiments. An activity of binary search is provided in a program. The activity can be stored as a structure storage 550, including data and meta data to allow the construction of two or more different representations. For example, a graphic diagram representation 630 can be generated from the structure storage 650, using the meta data as templates to construct the graphic diagram 630. The graphic diagram generation can be performed by a graphic diagram view or editor, mapping the structure storage 550 to the graphic diagram representation 635.

In some embodiments, a structure storage is provided that contains information, e.g., data and meta data, for the construction of different representations. In some embodiments, a first mapping program is provided to map, e.g., convert or construct, the structure storage to a particular representation. For example, a source code mapping program can map a structure storage to a source code representation. A graphic diagram mapping program can map a structure storage to a graphic diagram representation. In some embodiments, a second mapping program is provided, which includes an inverse of the mapping program that map the structure storage to a representation. The second mapping program can map a particular representation to a structure storage. The second mapping program can contain additional information to construct the structure storage so that the structure storage can be mapped into other representations. For example, a source code saving program, e.g., a second mapping program that can save a source code to a structure storage, can map a source code representation into a structure storage, which can be re-mapped to a source code representation as well as re-mapped to at least another representation such as a graphic diagram representation.

In some embodiments, the structure storage can provide a number of benefits due to the addition of the graphic diagram representation to the source code representation. For example, a graphical program representation may provide a much better visual representation of the operation of the program. In addition, various graphical program debugging features may be available, such as block execution highlighting that illustrates data flow in the program, which are not available in a text based language. Further, the graphical program may inherently support parallelism in execution, e.g., parallel execution on multiple processor cores, which is generally unavailable in a sequential text based program.

Figs. 7A - 7C illustrate flowcharts for storing a program in a structure storage format according to some embodiments. In Fig. 7A, operation 710 stores a program as a structure storage, with the structure storage configured to be represented by a text editor and a graphic editor. The structure storage can contain multiple representations, including a source code representation and a graphic diagram representation. The structure storage can also include other representation, such as a browser representation. The structure storage can contain information to allow the formation of multiple representations. The information can include data and meta data, which are configured to allow the generation of multiple representations.

In some embodiments, methods are provided to save a representation as a structure storage. In Fig. 7B, operation 750 opens or edits, either by a text editor or a graphic editor, a program. Other editors can also be used. The program can have a structure storage format, e.g., containing multiple representations with one of these representations accessed by the text editor or the graphic editor. The program can have a source code format, e.g., containing only a source code representation such as a traditional source code program. The program can have a graphic diagram format, e.g., containing only a graphic diagram representation such as a traditional graphic diagram program.

The text editor or the graphic editor can be a special editor, which is configured to allow the opening and/or editing of traditional source code, traditional graphic diagram, or the present structure storage programs. For example, a text editor can open a traditional source code or a structure storage program, and display a source code representation. A graphic editor can open a traditional graphic diagram or a structure storage program, and display a graphic diagram representation.

The text editor or the graphic editor can also be configured to save the program in a structure storage format. Operation 760 saves the program as a structure storage, with the structure storage configured to be editable by a text editor and a graphic editor. The saving process can include information that allows the generation of other representations from the structure storage. For example, a program can be edited by a text editor, forming a source code representation. When saving, the saving process saves data and information that can allow the reconstruction of the source code representation. Further, the saving process also saves additional information that can allow the construction of other representations, such as a graphic diagram representation. Thus a program can be started with a source code structure, but after saving, the program can include a structure storage format, which contains information to allow the program to be represented by multiple representations, e.g., reading by multiple representation editors such as a text editor displaying a source code and a graphic editor displaying a graphic diagram, both of which are different representations of a same program. In some embodiments, methods are provided to open a program in any representation editor, and save the program to a structure storage format. In Fig. 7C, operation 780 opens, either by a text editor or a graphic editor, a program stored as a structure storage, with the structure storage configured to be editable by a text editor and a graphic editor. Operation 790 saves the program as a structure storage.

Figs. 8A - 8C illustrate flowcharts for compiling a program having a structure storage format according to some embodiments. In Fig. 8A, operation 810 compiles a program which is stored as a structure storage, wherein the structure storage is configured to be represented by a text editor and a graphic editor. In Fig. 8B, operation 830 saves a program as a structure storage, wherein the structure storage is configured to be editable by a text editor and a graphic editor. Operation 840 compiles the program. In Fig. 8C, operation 860 edits, opens, or starts, either by a text editor or a graphic editor, a program. Operation 870 stores the program as a structure storage, wherein the structure storage is configured to be editable by a text editor and a graphic editor. Operation 880 compiles the program. In addition, the structure storage can be interpreted.

Fig. 9 illustrates a flowchart for forming a program having a structure storage format according to some embodiments. Operation 910 creates, by an expert, a program by a graphic editor. Operation 920 stores the program as a structure storage, wherein the structure storage is configured to be editable by a text editor and a graphic editor. Operation 930 opens, by a software developer, the program by either a graphic editor or a text editor. Operation 940 modifies the program. Operation 950 stores the program as a structure storage.

In some embodiments, provided are methods and systems for mapping between a structure storage and a representation. The structure storage can include multiple, e.g., more than one, representations, such as a source code representation, a graphic diagram representation, or a browser representation. A first mapping can include a mapping from the structure storage to the representation. For example, a first mapping can map the structure storage to a source code representation, which can be viewed or edited by a text editor. Another first mapping can map the structure storage to a graphic diagram representation, which can be viewed or edited by a graphic editor. Yet another first mapping can map the structure storage to a browser

representation, which can be viewed or run by a browser. A second mapping can include a mapping from a representation to a structure storage. For example, a second mapping can map a source code representation to a structure storage. The source code representation can be a representation of a structure storage. The source code representation can be a source code, e.g., a source code program instead of a representation of a program. The mapping process can receive the data from the source code, and add the meta data related to the data so that the data can be reconstructed to at least another representation, such as a graphic diagram representation. Another second mapping can map a graphic diagram representation to a structure storage. The mapping process can receive the data from the graphic diagram (e.g., graphic diagram representation or actual graphic diagram program), and add the meta data related to the data so that the data can be reconstructed to at least another

representation, such as a source code representation. Yet another second mapping can map a browser representation to a structure storage. The mapping process can receive the data from the browser representation, and add the meta data related to the data so that the data can be reconstructed to at least another representation, such as a source code representation or a graphic diagram representation.

In some embodiments, provided are representation editors. The representation editor can include a source code editor, a graphic diagram editor, or a browser editor. The representation editor can start a new representation, open, edit, and/or modify an existing representation, and save an open representation to a structure storage. In addition, the representation editor can start a new program, open, edit, and/or modify an existing program, instead of a representation. For example, the representation editor can open a source code representation, e.g., a representation of a program that resembles a source code, instead of the program itself. The representation editor can also open a source code program, e.g., a program written by a text editor having the syntax of a source code. The representation editor can save the open representation or open program to a structure storage. The structure storage can allow the representation editor to re-open a representation of the structure storage in the representation format of the editor.

In some embodiments, within the context of the present specification, there is a distinction between a program and a representation. For example, a source code program is a program that includes a source code language. Programs written in a text editor for a text-based programming language are typical source code programs. In contrast, a source code representation is simply an aspect of a program, which can have different representation. A program having a structure storage format of the present invention can have more than one representation, such as a source code representation and a graphic diagram representation. In other words, a source code program has only a source code representation, while a structure storage program can have multiple representations.

In some embodiments, the mapping or editor can be a complete or a partial mapping or editor. A complete mapping or a complete editor can include all features of the programming language, thus can allow displaying or using all aspects of the language. Text editor for a source code program is typically a complete editor, meaning all features of the text-based language are included in the text editor. A partial mapping or editor can omit certain features of the programming language, for example, to allow showing or editing certain aspects of the language. For example, a partial graphic diagram mapping or a partial graphic editor can show a process flow or a flow chart of a program, with the detailed computation portion hidden.

Fig. 10 illustrates a diagram showing different mappings for a program according to some embodiments. A program can be stored in a structure storage format 1010, which can include, for example, source code and graphic diagram representations. The program, e.g., the structure storage 1010, can be partially mapped 1020 to form a partial representation 1030, such as a partial source code or partial graphic diagram. For example, a graphic mapping can be partial, such as only allowing flow chart or flowing diagram without any comments or computation details.

The structure storage 1010 can be fully mapped 1025 to form a full representation 1035, such as a full source code or full graphic diagram. For example, a source code mapping can be full (e.g., complete mapping), such as allowing all features and details of the program 1010.

Figs. 11 A - 1 IB illustrate flowcharts showing different mapping processes according to some embodiments. The partial mapping can be at different levels of completeness or details. Fig. 11 A shows an aspect of a partial mapping process from a structure storage to a

representation. The partial mapping is configured so that the structure storage contains more information than the representation. In operation 1110, a program can be received as a structure storage, wherein the structure storage is configured to be edited by a text editor and a graphic editor. In operation 1120, the program is partially mapped to a text-based program or a graphic- based program, wherein the structure storage program comprises more information than the text- based or the graphic-based program

Fig. 1 IB shows another aspect of a partial mapping process from a structure storage to a representation. The partial mapping is configured as to hide some features or aspects of the structure stored from being mapped. In operation 1150, a program can be received as a structure storage, wherein the structure storage is configured to be edited by a text editor and a graphic editor. In operation 1160, the program is partially mapped to a text-based program or a graphic- based program, wherein partially mapping comprises hiding one or more information from being mapped to the text-based or the graphic-based program.

The different levels of mapping, e.g., complete mapping or different levels of partial mapping, can allow the programming code to be displayed at different levels with varying degrees of detail. For example, while typical users will typically use an average level of detail to design their applications and hide technical details such as applied data structures, indexing methods, and reserved storage areas, software developers may prefer to carry out their work in an environment that provides a familiar level of technical depth. This feature can allow advanced users and software developers to be able to create applications together, quite literally, without discontinuity of media. For example, the users can focus on the data flow features and the outcome of the program without concerning with the programming details. The software developers can provide a complete program according to the users' specifications.

In some embodiments, virtual source codes, and methods to generate virtual source codes, are provided. The virtual source code can include a source code representation, together with additional features that can assist the programmers. For example, the virtual source code can behave like a source code, which can provide a familiar programming environment for a software developer. The virtual source code can include other programming-friendly features, such as the tooltip feature. The tooltip feature can provide additional information about the object or code portion at the location of the cursor. When a software programmer points the cursor over an item, such as term in the source code, a small box appears that can explain the structure or usage of the term. The tooltip feature can be used as an extension of program comments, for example, to provide comments, explanation, and definition for a class of object, a message, or a procedure. The virtual source code can include other features, such as an ability to select showing of different aspects of the representation. For example, only a framework of coding can be shown, to provide an overview and a flow structure of the program. Other details can be selected, such as comments, computation details or indexing information.

In some embodiments, provided is a hybrid editor for a program that has been stored in a structure storage format. The hybrid editor can include a graphic editor and a text, e.g., source code, editor. The graphic editor can be used to make data models and other models with the help of diagrams, and the text editor can be used to develop applications in the tradition way of making source code text. The hybrid editor can provide both graphic diagram and source code representations of the program. The hybrid editor can provide the user with a greater

understanding of the program's operation through the graphic diagram representation, in addition to a more intuitive debugging capability. The hybrid editor can also provide the user with a greater detail of the program's operation through the source code representation. Further, a textual program representation can facilitate the programming effort in certain complex situations. In some embodiments, the hybrid editor can be used to display a virtual source code representation. For example, the hybrid editor can display different aspects of the virtual source code, a flow diagram aspect through the graphic diagram portion, and a detailed computation aspect through the source code portion.

In some embodiments, the virtual code can be constructed with layers of information. For example, a first layer can include information regarding the data flow of the program. A second layer can include information regarding the explanation of the written codes. A third layer can include the detailed computation of the program. A fourth layer can include information regarding the index of the program. A fifth layer can include information regarding the explanation and definition of the terms and objects in the program.

The different layers can be stored in structure storage format, e.g., each layer can be shown by multiple representations, such as a source code representation or a graphic diagram representation. Further different layers can be shown by different representations. For example, the first layer containing information about the data flow can be shown by a graphic diagram representation. The third layer about the detailed computation can be shown by a source code representation. Fig. 12 illustrates a layer representation of a program according to some embodiments. A program 1210, which can be stored in a structure storage format, can be constructed as a layered program. Different aspects of the program can be stored in different layers, such as layer 1 through layer 4. Different mappings, e.g., mapping 1 through mapping 4, can be included to map the layers, which are stored in a structure storage format that can allow the construction of multiple representations. For example, layer 1 can contain information regarding the flowchart of the program 1210, which can be mapped by mapping 1 to a representation 1220 (e.g., graphic diagram or source code representation) that can be shown in an editor, such as a hybrid editor. Layer 2 can contain information regarding the documentation of the program 1210, which can be mapped by mapping 2 to a representation 1222 (e.g., graphic diagram or source code

representation) that can be shown in an editor, such as a hybrid editor. Layer 3 can contain information regarding the computation of the program 1210, which can be mapped by mapping 3 to a representation 1224 (e.g., graphic diagram or source code representation) that can be shown in an editor, such as a hybrid editor. Layer 4 can contain information regarding the index of the program 1210, which can be mapped by mapping 4 to a representation 1226 (e.g., graphic diagram or source code representation) that can be shown in an editor, such as a hybrid editor. Additional layers can be included, such as a layer for displaying tooltips, which provide explanation and definition for the terms in the source code representation of the program.

Fig. 13 illustrates a program showing one layer according to some embodiments. A program 1310, which can be stored in a structure storage format, can be constructed as a layered program. Only layer 1 can be shown in an editor, which include a graphic mapping to a graphic diagram representation 1320 and a source code mapping to a source code representation 1321.

Fig. 14 illustrates a program showing two layers according to some embodiments. A program 1410, which can be stored in a structure storage format, can be constructed as a layered program. Layers 1 and 2 can be shown in an editor, which include a graphic mapping to a graphic diagram representation 1420 and a source code mapping to a source code representation 1421.

Fig. 15 illustrates a program showing two other layers according to some embodiments. A program 1510, which can be stored in a structure storage format, can be constructed as a layered program. Layers 1 and 3 can be shown in an editor, which include a source code mapping to a source code representation 1521. Other mappings can be included, such as a graphic mapping.

Fig. 16 illustrates a program showing two other layers according to some embodiments. A program 1610, which can be stored in a structure storage format, can be constructed as a layered program. Layers 1 and 4 can be shown in an editor, which include a source code mapping to a source code representation 1621. Other mappings can be included, such as a graphic mapping.

Fig. 17 illustrates a program showing a tooltip according to some embodiments. A cursor 1770 can be pointed to a term in a source code representation 1721, and a hover box 1730 appears, showing the definition and structure of the class of object of the term.

Figs. 18A - 18D illustrate flowcharts for operating layered programs according to some embodiments. In Fig. 18A, a program can be stored, e.g., saved, as a layered structure storage. The storing in information in layers can facilitate the display of different aspects of the program, for example, by selecting appropriate layers to be shown. Operation 1810 saves a program as a layered structure storage, wherein the layered structure storage comprises a plurality of layers, wherein each layer comprises at least an aspect of the program.

In Fig. 18B, different layers can be used to store different aspects of the program.

Operation 1820 saves a program as a layered structure storage, wherein the layered structure storage comprises a plurality of layers, wherein a first layer comprises a flow of the program, wherein a second layer comprises a documentation of the program, wherein a third layer comprises an index of the program, wherein a fourth layer comprises a computation of the program.

In Fig. 18C, each layer in a layered structure storage can be configured to include different representations. Operation 1830 saves a program as a layered structure storage, wherein the layered structure storage comprises a plurality of layers, wherein each layer comprises at least an aspect of the program, wherein each layer is configured to be edited by a text editor or a graphic editor

In Fig. 18D, an editor, such as a hybrid editor, can be used to display different layers in different representations. Operation 1840 saves a program as a layered structure storage, wherein the layered structure storage comprises a plurality of layers, wherein each layer comprises at least an aspect of the program, wherein a first layer is configured to be edited by a text editor or a graphic editor, wherein a second layer is configured to be edited by the text editor.

Figs. 19A - 19D illustrates another flowchart for operating a layered program according to some embodiments. In Fig. 19A, a program can be opened, which has been stored, e.g., saved, as a layered structure storage. The storing in information in layers can facilitate the display of different aspects of the program, for example, by selecting appropriate layers to be shown.

Operation 1910 opens a program, which was stored as a layered structure storage. The layered structure storage can include a plurality of layers, wherein each layer has at least an aspect of the program. Operation 1920 selects one or more layers for viewing.

In Fig. 19B, different layers can be used to store different aspects of the program.

Operation 1940 opens a program which was stored as a layered structure storage, wherein the layered structure storage comprises a plurality of layers, wherein each layer comprises at least an aspect of the program. Operation 1950 selects a first layer to view the program without details. Operation 1960 selects a second layer to view the program with details.

In Fig. 19C, each layer in a layered structure storage can be configured to include different representations. Operation 1970 opens a program which was stored as a layered structure storage by a graphic editor or a source code editor to view the program without details. In Fig. 19D, operation 1990 opens a program stored as a layered structure storage by a source code editor to view the program with details.

In some embodiments, provided is a machine readable storage, having stored there on a computer program having a plurality of code sections for causing a machine to perform the various steps and/or implement the components and/or structures disclosed herein. In some embodiments, the present invention may also be embodied in a machine or computer readable format, e.g., an appropriately programmed computer, a software program written in any of a variety of programming languages. The software program would be written to carry out various functional operations of the present invention. Moreover, a machine or computer readable format of the present invention may be embodied in a variety of program storage devices, such as a diskette, a hard disk, a CD, a DVD, a nonvolatile electronic memory, or the like. The software program may be run on a variety of devices, e.g. a processor. In some embodiments, the methods can be realized in hardware, software, or a combination of hardware and software. The methods can be realized in a centralized fashion in a data processing system, such as a computer system or in a distributed fashion where different elements are spread across several interconnected computer systems. Any kind of computer system or other apparatus adapted for carrying out the methods described herein can be used. A typical combination of hardware and software can be a general-purpose computer system with a computer program that can control the computer system so that the computer system can perform the methods. The methods also can be embedded in a computer program product, which includes the features allowing the implementation of the methods, and which when loaded in a computer system, can perform the methods.

The terms "computer program", "software", "application", variants and/or combinations thereof, in the context of the present specification, mean any expression, in any language, code or notation, of a set of instructions intended to cause a system having an information processing capability to perform a particular function either directly. The functions can include a conversion to another language, code or notation, or a reproduction in a different material form. For example, a computer program can include a subroutine, a function, a procedure, an object method, an object implementation, an executable application, an applet, a servlet, a source code, an object code, a shared library/dynamic load library and/or other sequence of instructions designed for execution on a data processing system, such as a computer.

In some embodiments, the methods can be implemented using a data processing system, such as a general purpose computer system. A general purpose computer system can include a graphical display monitor with a graphics screen for the display of graphical and textual information, a keyboard for textual entry of information, a mouse for the entry of graphical data, and a computer processor. In some embodiments, the computer processor can contain program code to implement the methods. Other devices, such as a light pen (not shown), can be substituted for the mouse. This general purpose computer may be one of the many types well known in the art, such as a mainframe computer, a minicomputer, a workstation, or a personal computer.

Fig. 20 illustrates a computing environment according to some embodiments. An exemplary environment 2000 for implementing various aspects of the invention includes a computer 2001, comprising a processing unit 2031, a system memory 2032, and a system bus 2030. The processing unit 2031 can be any of various available processors, such as single microprocessor, dual microprocessors or other multiprocessor architectures. The system bus 2030 can be any type of bus structures or architectures, such as 12-bit bus, Industrial Standard Architecture (ISA), Micro-Channel Architecture (MSA), Extended ISA (EISA), Intelligent Drive Electronics (IDE), VESA Local Bus (VLB), Peripheral Component Interconnect (PCI),

Universal Serial Bus (USB), Advanced Graphics Port (AGP), Personal Computer Memory Card International Association bus (PCMCIA), or Small Computer Systems Interface (SCST).

The system memory 2032 can include volatile memory 2033 and nonvolatile memory 2034. Nonvolatile memory 2034 can include read only memory (ROM), programmable ROM (PROM), electrically programmable ROM (EPROM), electrically erasable ROM (EEPROM), or flash memory. Volatile memory 2033, can include random access memory (RAM), synchronous RAM (SRAM), dynamic RAM (DRAM), synchronous DRAM (SDRAM), double data rate SDRAM (DDR SDRAM), enhanced SDRAM (ESDRAM), Synchlink DRAM (SLDRAM), or direct Rambus RAM (DRRAM).

Computer 2001 also includes storage media 2036, such as removable/nonremovable, volatile/nonvolatile disk storage, magnetic disk drive, floppy disk drive, tape drive, Jaz drive, Zip drive, LS-100 drive, flash memory card, memory stick, optical disk drive such as a compact disk ROM device (CD-ROM), CD recordable drive (CD-R Drive), CD rewritable drive (CD-RW Drive) or a digital versatile disk ROM drive (DVD-ROM). A removable or non-removable interface 2035 can be used to facilitate connection.

The computer system 2001 further can include software to operate in environment 2000, such as an operating system 2011, system applications 2012, program modules 2013 and program data 2014, which are stored either in system memory 2032 or on disk storage 2036. Various operating systems or combinations of operating systems can be used.

Input devices 2022 can be used to enter commands or data, and can include a pointing device such as a mouse, trackball, stylus, touch pad, keyboard, microphone, joystick, game pad, satellite dish, scanner, TV tuner card, sound card, digital camera, digital video camera, web camera, and the like, connected through interface ports 2038. Interface ports 2038 can include a serial port, a parallel port, a game port, a universal serial bus (USB), and a 1394 bus. The interface ports 2038 can also accommodate output devices 2021. For example, a USB port may be used to provide input to computer 2001 and to output information from computer 2001 to an output device 2021. Output adapter 2039, such as video or sound cards, is provided to connect to some output devices such as monitors, speakers, and printers.

Computer 2001 can operate in a networked environment with remote computers 2024. The remote computers 2024, shown with a memory storage device 2025, can be a personal computer, a server, a router, a network PC, a workstation, a microprocessor based appliance, a peer device or other common network node and the like, and typically includes many or all of the elements described relative to computer 2001. Remote computers 2024 can be connected to computer 2001 through a network interface 2023 and communication connection 2037, with wire or wireless connections. Network interface 2023 can be communication networks such as local- area networks (LAN), wide area networks (WAN) or wireless connection networks. LAN technologies include Fiber Distributed Data Interface (FDDI), Copper Distributed Data Interface (CDDI), Ethernet/IEEE 1202.3, Token Ring/IEEE 1202.5 and the like. WAN technologies include, but are not limited to, point-to-point links, circuit switching networks like Integrated Services Digital Networks (ISDN) and variations thereon, packet switching networks, and Digital Subscriber Lines (DSL).

Fig. 21 is a schematic block diagram of a sample computing environment 2100 with which the present invention can interact. The system 2140 includes a plurality of client systems

2141. The system 2140 also includes a plurality of servers 2143. The servers 2143 can be used to employ the present invention. The system 2140 includes a communication network 2145 to facilitate communications between the clients 2141 and the servers 2143. Client data storage

2142, connected to client system 2141, can store information locally. Similarly, the server 2143 can include server data storages 2144.

In some embodiments, the present invention discloses a machine-implemented method including storing a program as a structure storage. The program can include a software program, such as computer program code or software code, which is a sequence of instructions to perform a specified task with a data processing system, such as a computer. A central processor in a computer can execute the program's instructions. The program can have an executable form that the computer can use directly to execute the instructions. The program can have human-readable form, such as a textual representation or a graphical representation. A collection of computer programs and related data can be referred to as the software.

The structure storage can include metadata, which is configured to allow constructing the program as a textual representation and as a graphical representation. The textual representation can include the program instructions in text form, such as a source code representation of the program. The graphical representation can include the program instructions in graphic diagram form, such as a graphical diagram representation of the program.

The metadata can include elements of objects of the programs and information to allow constructing the objects from the elements by the graphic editor or by the text editor. The metadata can include data, which includes elements of objects of the programs, and commands, which include information to allow constructing the objects from the data by the graphic editor or by the text editor. The data can include object information describing the program. The commands can include formatting information to allow constructing the program by the graphic editor or by the text editor. The commands comprise instructions to create the graphical representation or to create the textual representation from the program data.

For example, the data can include components of classes, decision making such as if- then-else components, looping such as for or while components. In general the data can include elements of a graphical representation, such as elements of the graphic diagram of the program, and elements of a textual representation, such as elements of the source code of the program. The elements are shared, e.g., one element can be used for both graphical representation and textual representation. For example, one element or two synchronized elements can be used for both representations. The synchronization between same elements of different representations can assure the consistency of the program.

For example, the metadata can include elements of objects of the programs and information to allow generating a source code representation of the program. The metadata can also include elements of objects of the programs and information to allow generating a graphical diagram representation of the program.

The data can include first data common for both the graphical representation and the textual representation. The data can include second data specific for the textual representation, such as computational details of the program. The commands can include instructions to create the graphical representation from the first data, or to create the textual representation from the first and second data.

The data can include third data specific for the graphical representation, such as flow diagram. The commands can include instructions to create the graphical representation from the first and third data.

The data can include first data common for both the graphical representation and the textual representation. The data can include second data specific for the textual representation. The data can include third data specific for the graphical representation. The commands can include instructions to create the textual representation from the first and second data, or to create the graphical representation from the first and third data.

In some embodiments, the program can be first created as the textual representation or a graphical representation, before being stored as a structure storage. A program can be opened by a text editor, which can form a textual representation of the program. The text editor can edit the program, and then store, e.g., save, the program as a structure storage. A program can be opened by a graphic editor, which can form a graphical representation of the program. The graphic editor can edit the program, and then store, e.g., save, the program as a structure storage.

In some embodiments, the structure storage can be stored in a recordable type medium, such as a hard drive, a CD ROM, or a solid state drive. The recordable-type medium can have a sequence of instructions which when executed by a computer, cause the computer to storing a program as a structure storage. A data processing system can be used, including a processor; and a memory coupled to the processor storing instructions which when executed by the processor cause the processor to storing a program as a structure storage. A program can be represented by a virtual source code, which can include a graphical representation of the program, a textual representation of the program, together with a synchronization between the elements of the two representations.

In some embodiments, the present invention discloses a method including providing a structure storage, and selecting an option for viewing the structure storage as a textual representation or as a graphical representation. The method can include selecting the option of opening the structure storage as the textual representation, and then optionally editing the textual representation. The edited textual representation can also be saved, e.g., stored, as a structure storage, e.g., a new structure storage representing the edited program. The method can include selecting the option of opening the structure storage as the graphical representation, and then optionally editing the graphical representation. The edited graphical representation can also be saved, e.g., stored, as a structure storage, e.g., a new structure storage representing the edited program.

In some embodiments, providing a structure storage can include accessing a structure storage by a text editor, and selecting an option for viewing the structure storage comprises automatically opening the structure storage as a textual representation. Providing a structure storage can include accessing a structure storage by a graphic editor, and selecting an option for viewing the structure storage comprises automatically opening the structure storage as a graphical representation.

In some embodiments, the structure storage can be created from a textual representation, such as a source code. For example, a program can be created or opened as a textual

representation, e.g., by a text editor, and then saved as a structure storage. The structure storage can be created from a graphical representation, such as a graphic diagram. For example, a program can be created or opened as a graphical representation, e.g., by a graphic editor, and then saved as a structure storage.

In some embodiments, the present invention discloses a mapping program, such as a virtual source code editor, which can access a structure storage. The virtual source code editor can include a first module for accepting a structure storage as an input, a second module for opening the structure storage as a textual representation, and a third module for opening the structure storage as a graphical representation. The virtual source code editor can be stored in a recordable type medium, such as a hard drive, a CD ROM, or a solid state drive. The recordable- type medium can have a sequence of instructions which when executed by a computer, cause the computer to accepting a structure storage, and offering an option for viewing the structure storage as a textual representation or as a graphical representation. A data processing system can be used, including a processor; and a memory coupled to the processor storing instructions which when executed by the processor cause the processor to accepting a structure storage, and offering an option for viewing the structure storage as a textual representation or as a graphical representation. In some embodiments, the present invention discloses a method including creating or opening a graphical representation of a program using a graphic editor, storing the graphical representation as a first structure storage, opening a textual representation of the first structural storage by a text editor, and storing the textual representation as a second structure storage. After opening or creating the graphical representation by a graphic editor, the method can further include editing the graphical representation using the graphic editor. After opening or creating the textual representation by a text editor, the method can further include editing the textual representation using the text editor. The graphical representation comprises a flow diagram of the program. The textual representation comprises a computation algorithm of the program. The method can further include opening the second structure storage as the graphical representation, editing the graphical representation, and saving the edited graphical representation as a third structure storage.

In some embodiments, the present invention discloses a method including creating or opening a textual representation of a program using a text editor, storing the textual

representation as a first structure storage, opening a graphical representation of the first structural storage by a graphic editor, storing the graphical representation as a second structure storage.

Having thus described certain preferred embodiments of the present invention, it is to be understood that the invention defined by the appended claims is not to be limited by particular details set forth in the above description, as many apparent variations thereof are possible without departing from the spirit or scope thereof as hereinafter claimed.

Claims

What is claimed is

1. A machine-implemented method comprising

storing a program as a structure storage,

wherein the structure storage comprises metadata,

wherein the metadata is configured to allow constructing the program as a textual representation and as a graphical representation.

2. A method as in claim 1

wherein the textual representation comprises a source code representation of the program.

3. A method as in claim 1

wherein the graphical representation comprises a graphical diagram representation of the program.

4. A method as in claim 1

wherein the metadata comprises elements of objects of the programs and information to allow constructing the objects from the elements by a graphic editor or by a text editor.

5. A method as in claim 1

wherein the metadata comprises elements of objects of the programs and information to allow generating a source code representation of the program; wherein the metadata comprises elements of objects of the programs and information to allow generating a graphical diagram representation of the program.

6. A method as in claim 1

wherein the metadata comprises program data and commands,

wherein the commands comprise instructions to create the graphical representation or to create the textual representation from the program data.

7. A method as in claim 1

wherein the metadata comprises data and commands,

wherein the data comprises first data common for both the graphical representation and the textual representation,

wherein the data comprises second data specific for the textual representation, wherein the commands comprise instructions to create the graphical representation from the first data, or to create the textual representation from the first and second data.

8. A method as in claim 1

wherein the second data comprises computational details.

9. A method as in claim 1

wherein the metadata comprises data and commands,

wherein the data comprises first data common for both the graphical representation and the textual representation,

wherein the data comprises third data specific for the graphical representation, wherein the commands comprise instructions to create the graphical representation from the first and third data.

10. A method as in claim 1

wherein the third data comprises flow diagram.

11. A method as in claim 1

wherein the metadata comprises data and commands,

wherein the data comprises first data common for both the graphical representation and the textual representation,

wherein the data comprises second data specific for the textual representation, wherein the data comprises third data specific for the graphical representation, wherein the commands comprise instructions to create the textual representation from the first and second data, or to create the graphical representation from the first and third data.

12. A method as in claim 1 further comprising

creating the program as the textual representation.

13. A method as in claim 1 further comprising

creating the program as the graphical representation.

14. A method as in claim 1 further comprising

opening the program by a text editor.

15. A method as in claim 1 further comprising

opening the program by a text editor; editing the program.

16. A method as in claim 1 further comprising

opening the program by a graphic editor to form the graphical representation.

17. A method as in claim 1 further comprising

opening the program by a graphic editor;

editing the program.

18. A recordable-type medium having stored thereon a sequence of instructions which when executed by a computer, cause the computer to perform a method comprising:

storing a program as a structure storage,

wherein the structure storage comprises metadata,

wherein the metadata is configured to allow constructing the program as a textual representation and as a graphical representation.

19. A data processing system comprising:

a processor; and

a memory coupled to the processor, the memory storing instructions which when executed by the processor cause the processor to perform a method comprising: storing a program as a structure storage,

wherein the structure storage comprises metadata,

wherein the metadata is configured to allow constructing the program as a textual representation and as a graphical representation.

20. A structure storage comprising metadata

wherein the metadata is configured to allow constructing the program as a textual representation and as a graphical representation.

21. A virtual source code for a program, comprising

a graphical representation of the program;

a textual representation of the program,

wherein the graphical representation and the textual representation are synchronized.

22. A machine-implemented method comprising

providing a structure storage; selecting an option for viewing the structure storage as a textual representation or as a graphical representation.

23. A method as in claim 22 further comprising

opening the structure storage as the textual representation;

editing the textual representation.

24. A method as in claim 22 further comprising

saving the edited textual representation as structure storage.

25. A method as in claim 22 further comprising

opening the structure storage as the graphical representation;

editing the graphical representation.

26. A method as in claim 22 further comprising

saving the edited graphical representation as structure storage.

27. A method as in claim 22

wherein providing a structure storage comprises accessing a structure storage by a text editor;

wherein selecting an option for viewing the structure storage comprises automatically opening the structure storage as a textual representation.

27. A method as in claim 22

wherein providing a structure storage comprises accessing a structure storage by a graphic editor;

wherein selecting an option for viewing the structure storage comprises automatically opening the structure storage as a graphical representation.

29. A method as in claim 22 further comprising

creating a program as the textual representation;

saving the textual representation as the structure storage.

30. A method as in claim 22 further comprising

creating a program as the graphical representation;

saving the graphical representation as the structure storage.

31. A method as in claim 22 further comprising

opening a program by a text editor to form the textual representation;

saving the textual representation as the structure storage. A method as in claim 22 further comprising

opening a program by a graphic editor to form the graphical representation.

saving the graphical representation as the structure storage.

A recordable-type medium having stored thereon a sequence of instructions which when executed by a computer, cause the computer to perform a method comprising:

providing a structure storage;

selecting an option for viewing the structure storage as a textual representation or as a graphical representation.

A data processing system for managing electronic communication, the data processing system comprising:

a processor; and

a memory coupled to the processor, the memory storing instructions which when executed by the processor cause the processor to perform a method comprising: providing a structure storage;

selecting an option for viewing the structure storage as a textual representation or as a graphical representation.

A virtual source code editor comprising

a first module for accepting a structure storage as an input;

a second module for opening the structure storage as a textual representation;

a third module for opening the structure storage as a graphical representation.

A machine-implemented method comprising

creating or opening a graphical representation of a program using a graphic editor; storing the graphical representation as a first structure storage;

opening a textual representation of the first structural storage by a text editor;

storing the textual representation as a second structure storage.

A method as in claim 36 further comprising

editing the graphical representation using the graphic editor.

A method as in claim 36 further comprising

editing the textual representation using the text editor.

39. A method as in claim 36

wherein the graphical representation comprises a flow diagram of the program.

40. A method as in claim 36

wherein the textual representation comprises a computation algorithm of the program.

41. A method as in claim 36 further comprising

opening the second structure storage as the graphical representation;

editing the graphical representation.

42. A method as in claim 36 further comprising

saving the edited graphical representation as a third structure storage.

43. A machine-implemented method comprising

creating or opening a textual representation of a program using a text editor; storing the textual representation as a first structure storage;

opening a graphical representation of the first structural storage by a graphic editor; storing the graphical representation as a second structure storage.