Abstract: A software development system according to the present invention comprises a business component storage layer for storing at least one business standard component of a program; a business component setting layer for setting attribute information of each business standard object, including object type, operating method, execution condition, execution sequence and database (DB) connection information; an application program execution layer for operating and controlling the object in the business component storage layer by the attribute information of the objects set by the user, and performing comparison, execution or calculation according to logic defined in script language; and an environment abstraction layer for controlling information technology (IT) infrastructure including an operating system of a computer, a central processing unit (CPU), a memory, a database management system (DBMS), network and display apparatus.

Abstract: A system and method for creating a graphical program utilizing one or more nodes which are statically bound to one or more virtual instruments (VIs). The system and method for static binding provides a way to interact individually with controls and indicators of a VI running asynchronously, wherein the values read and written are strictly typed to the data type of the control. The overhead of dynamic invocation may be substantially eliminated to allow for greater efficiency.

Abstract: Methods, systems, and apparatus, including computer program products, for storing an application fragment. In one aspect, a method includes presenting a component in a donor application window corresponding to a donor application, wherein the donor application is executing in a computing system; receiving input selecting the component in the donor application window for insertion into a file system associated with the computing system; generating an application fragment corresponding to the component; and storing the application fragment in the file system. Further, the method can include inserting the application fragment into a recipient application window associated with a recipient application and activating functionality of the recipient application based on the application fragment. Additionally, the application fragment can be activated in the file system and an application including at least a component based on the application fragment can be generated in response to the activating.

Abstract: System and method for generating a data flow diagram. A first case structure may be specified. Each case of the first case structure that includes a respective plurality of input bound data flow nodes may be partitioned into one or more data flow diagram portions. The first case structure may be replaced with a first conditional structure and one or more second conditional structures. The first conditional structure may be operable to select one or more of the plurality of input bound data flow diagram portions in accordance with the conditions of the first case structure. The one or more second conditional structures may be operable to select at least one output from the plurality of input bound data flow diagram portions in accordance with the conditions of the first case structure. The partitioning and replacing may be performed automatically in response to specification of the first case.

Abstract: Various technologies and techniques are disclosed performing a bidirectional synchronization between a visual representation and a textual representation. A visual representation of a file is synchronized with a textual representation of a file using a same delta propagation that is used to synchronize the textual representation with the visual representation. A semantic view is generated for the visual representation, and a separate semantic view is generated for the textual representation of the file. The visual representation and the textual representation follow a same semantic structure for comparison. To perform synchronization after changes are made to one of the representations, a synchronization process is performed using the semantic views to update the other representation.

Abstract: The present invention allows a user to graphically define a hierarchy of user-defined, executable classes of graphical objects that can be implemented in a graphical model. The present invention supports the features of inheritance, abstraction and polymorphism. Further, descendant classes of graphical objects can graphically extend the behavior and/or structure of ancestor classes of graphical objects.

Abstract: An object-oriented, computer-based system for developing simulation models is provided. The system comprises one or more base objects and one or more graphical processes, wherein new objects are created from base objects by a user by assigning one or more graphical processes to the base object(s). New objects are created without the need for methods or computer programming. A model is built by creating objects that represent the physical components of the system being modeled into the model, and then running the model.

Abstract: Methods, systems, and apparatus, including computer program products, for reusing a component. In one aspect, a method includes executing a source application in an application environment; presenting a reusable component in a source application window corresponding to the source application, wherein the reusable component is visibly distinguishable from one or more non-reusable components displayed in the source application window; receiving input selecting the reusable component in the source application window and adding the reusable component to a target application window corresponding to a target application; and inserting one or more computer-readable instructions associated with the reusable component into the target application. Further, input can be received to activate a reuse function associated with the source application.

Abstract: System and method for merging graphical programs. Information is received regarding first, second, and third graphical programs, where the third graphical program is an ancestor graphical program of the first and second. The information is analyzed to determine differences among the graphical programs. The first and second graphical programs are merged based on the determined differences, generating a merged graphical program, which is displayed.

Abstract: A method for providing codebase modification assistance includes receiving training data including learning application code prior to modification and the same learning application code subsequent to modification, the modification being of a known type. Portions of the learning application code that have been changed by the modification are detected. One or more substrings are identified from names associated with the detected portions of the learning application code that have been changed. A target application code that is to be modified according to the known type of modification of the training data is received. The identified one or more substrings are searched for from names associated with portions of the received target application code. The portions of the target application code for which the one or more substrings have been found within associated names are displayed.

Abstract: The present disclosure is directed toward a method for hierarchical hardware mapping in a software design environment. The method comprises the step of providing a software design tool on a graphical interface of a computer system. The method also includes receiving, in the software design tool, graphical representation of at least a portion of software and receiving, in the software design tool, graphical representation of at least a portion of hardware. The method may further include receiving, in the software design tool, one or more bindings between software and hardware, wherein the one or more bindings form a set of bindings, and storing the set of bindings for use in one or more software designs.

Abstract: System and method for creating a graphical program that uses multiple models of computation (MoC). A first plurality of graphical program elements is assembled in a graphical program in response to first input, where the assembled first plurality of graphical program elements have a first MoC. A structure is displayed in the graphical program indicating use of a second MoC for graphical program elements comprised within the interior of the structure. A second plurality of graphical program elements is assembled within the structure in response to second input, where the assembled second plurality of graphical program elements have the second MoC. The graphical program is executable to perform a function, for example, by executing the assembled first plurality of graphical program elements in accordance with the first model of computation, and executing the assembled second plurality of graphical program elements in accordance with the second model of computation.

Abstract: The invention includes a method and apparatus for upgrading software represented as a graph, where the graph has a plurality of states and a plurality of state transitions and tokens traverse the graph executing functions. A method includes identifying a target region of the graph, obtaining a new region for the graph, determining a correspondence between states of the target region of the graph and states of the new region for the graph, and replacing the target region of the graph with the new region for the graph using the correspondence between states of the target region of the graph and states of the new region for the graph. The target region of the graph may be replaced by suspending the operation of the target region of the graph, or while the target region of the graph continues running.

Abstract: An automated software production system is provided, in which system requirements are captured, converted into a formal specification, and validated for correctness and completeness. In addition, a translator is provided to automatically generate a complete, robust software application based on the validated formal specification, including user-interface code and error handling code.

Abstract: An integrated development system for editing computer software code defines an annotation that includes an annotation identifier, at least one value, and an associated language for each value. The system displays the annotation identifier with a first value in an editing user interface. The system detects that a user is editing the first value. In response to the detecting, the system automatically revises the display of the first value based on a corresponding first language.

Abstract: The invention includes a method and apparatus for dynamically defining and instantiating an undefined portion of a graph, where the graph has a plurality of states and a plurality of state transitions. A method includes executing the graph where the graph comprises a defined portion and an undefined portion and a plurality of tokens traverse the graph executing functions, suspending the one of the tokens in response to the one of the tokens detecting the undefined portion of the graph, generating a new portion of the graph for the undefined portion of the graph, replacing the undefined portion of the graph with the new portion of the graph, and releasing the suspended token. The new portion of the graph is generated by generating at least one definition file for the undefined portion of the graph and executing the at least one definition file to form thereby the new portion of the graph.

Abstract: A model for an application program is displayed. The model includes an input interface, an output interface, and a plurality of variables. Addition of a new variable and placement of an annotation on the display unit for the new variable is detected. The annotation identifies the new variable as an individually definable object or an identification key. The identification key identifies an individual situation and the individually definable object copes with the individual situation. A new model with a new input interface and a new output interface is generated based, at least in part, on the annotation identifying the new variable as an individually definable object or an identification key.

Abstract: A task based polymorphic graphical program node system and method. A node is displayed in a graphical program. First user input is received invoking display of a plurality of function type options for the node, and the function type options for the node displayed. Second user input is received specifying a function type from the function type options. Based on the second user input, program instructions executable to provide functionality in accordance with the specified function type are determined and associated with the node, after which the node is executable in the graphical program to provide the functionality in accordance with the specified function type. Associating the program instructions with the node may include configuring the (possibly generic) node with the program instructions, replacing default program instructions of the node implementing default node functionality with the program instructions, and/or replacing the node with another node that includes the program instructions.

Abstract: In a system in which documents are generated dynamically in response to user requests, historical data is collected regarding data retrieval subtasks, such as service requests, that are performed to generate such documents. This data is used to predict the specific subtasks that will be performed to respond to specific document requests, such that these subtasks may be initiated preemptively at or near the outset of the associated document generation task. A subtask that would ordinarily be postponed pending the outcome of a prior subtask can thereby be performed in parallel with the prior subtask, reducing document generation times. In one embodiment, the historical data is included within, or is used to generate, a mapping table that maps document generation tasks (which may correspond to specific URLs) to the data retrieval subtasks that are frequently performed within such tasks.

Abstract: Methods, systems, and apparatus, including computer program products, in which input method editor code is provided to a client device, and an input method context is received from the client device. A library model for an input method instance based on the input method context is selected. The library model can be utilized to provide input method processing for an input method instance on the client device.

Abstract: The invention relates to a programming surface for imperative, procedural languages. A further prerequisite is a graphical user interface (GUI). The programming surface for the input of program code can be used with known programming languages such as Visual Basic, Java, C++. In the case of the programming surface, there is no longer a need to key in the program instructions. A language syntax need not be observed. An instruction set need not be learned.

Abstract: Techniques for developing a graphical editor using an incremental development approach. Externally-stored descriptors are used to specify information on which a graphical editor engine operates to create a graphical editor. Developers can thus redefine the look and feel of the graphical editor by modifying these descriptors, effectively re-configuring the elements of visual models without changing the code of the graphical editor engine. Visual models for modeling a domain can be created and used, without first requiring the domain model to be defined.

Abstract: System and method for implementing multi-channel operations in a programmable hardware element (PHE). A hardware configuration program, including a processing function, inputs and outputs of the processing function, a plurality of channels, and channel scanning functionality for the plurality of channels, is specified. A PHE is configured with the hardware configuration program, including implementing the processing function and the channel scanning functionality on the PHE. A respective state and configuration of each of the plurality of channels is stored in a memory of the PHE to enable logic-sharing between each of the plurality of channels. The PHE is operated, including performing channel scanning on the plurality of channels, and updating the configuration of one or more of the channels in the memory of the PHE without interrupting the channel scanning, without taking any of the channels offline, and/or without interrupting a continuity of an output of the PHE.

Abstract: System and method for creating, configuring, representing, and using variables in programs. A graphical user interface (GUI) may be displayed in response to user input requesting creation and/or configuration of a variable for use in or comprised in one or more programs, e.g., on various devices. User input is received to the GUI configuring attributes of the variable, including: name, data type, and/or scope (e.g., local, global, or network). The configured attributes are stored and optionally displayed, e.g., in a resource tree, and the variable in each of the programs updated in accordance with the configured attributes. When at least one of the programs is incompatible with the configured variable, an error condition may be indicated, e.g., by providing information relating to portions of the program that are incompatible with the configured variable. The program may be modified in response to user input for compatibility with the configured variable.

Abstract: A system and method for receiving code that is submitted for integrating code into a software application. In one embodiment, a method includes receiving information associated with the code; displaying the information associated with the code; verifying the information associated with the code; and if the information associated with the code successfully verifies, generating a stamp associated with the code and with the software application.

Abstract: Various techniques for interacting with a test case via a graphical model are disclosed. For example, one method involves displaying a first icon, which represents a first testing activity within a test case; displaying a second icon, which represents a second testing activity within the test case; and displaying a connector, which couples the first icon and the second icon. An assertion (e.g., against test results obtained by performing the first testing activity) is associated with the connector.

Abstract: Techniques for developing a graphical editor using an incremental development approach. Externally-stored descriptors are used to specify information on which a graphical editor engine operates to create a graphical editor. Developers can thus redefine the look and feel of the graphical editor by modifying these descriptors, effectively re-configuring the elements of visual models without changing the code of the graphical editor engine. Visual models for modeling a domain can be created and used, without first requiring the domain model to be defined.

Abstract: Certain exemplary embodiments provide a method for highlighting selected tasks in a program code listing comprising: converting the program code listing to a mark-up language; inserting instructions at a starting point and at an ending point; and testing if highlighting is to be turned on at a point in the program code listing by the instructions provided at the starting point.

Abstract: A system and method for creating a distributed application using graphical programming techniques are disclosed. The distributed application may comprise a first graphical program and a second graphical program, where a host computer system executes the first graphical program, and a plurality of remote computer systems or computing devices each execute an instance of the second graphical program. In some embodiments the first graphical program may utilize a node that represents the second graphical program. The node may be operable to exchange data with a plurality of instances of the second graphical program executing on a plurality of remote devices.

Abstract: Configuring wires/icons in a diagram. The diagram may be an executable diagram such as a graphical program or a system diagram. The diagram may include a plurality of icons that are connected by wires, and the icons may visually represent functionality of the diagram. The diagram may be executable to perform the functionality. Displaying the diagram may include displaying a first wire in the diagram, where the first wire connects a first icon and a second icon. Data transfer functionality may be specified for the first wire and/or the first or second icon in the diagram. The data transfer functionality may be visually indicated in the diagram, e.g., by appearances of the first icon, the second icon, the first wire, and/or icons displayed proximate to these components of the diagram.

Abstract: Exemplary embodiments employ a mapping among entities that are related to each other. The entities may include a graphical model, generated code, a generated report, a requirements document and/or an intermediate representation. The mapping may facilitate graphical identifications between parts of one entity that maps to part of another entity. The graphical identification may occur based on a selection of a part in one of the entities.

Abstract: Various technologies and techniques are disclosed for creating interruptible client-side scripts. Input is received from a developer to write original code for a web application in at least one client-side script. A code injection process is programmatically performed to modify the original code to make one or more parts of an execution of the code interruptible in the client-side script. The code injection process parses a code segment of a client-side script to retrieve a next code segment. If the next code segment has at least one conditional semantic construct, then code is injected in the form of one or more script functions that will transition execution flow from the original code segment into the one or more script functions that are operable to interrupt execution of the client-side script upon user request. The modified code resulting from the code injection process is saved for the web application.

Abstract: An unresolved defect can be identified in a computer program product. It may not be initially known which of a plurality of different code segments of the computer program product are able to be modified to correct to repair the unresolved defect. A subset of the different code segments can be predicted utilizing information contained within a database of previously reported defects. The predicting can be determined based on a set of code segments that were previously modified to correct or repair the previously reported defects as detailed within the database.

Abstract: During execution of a program, a processor may identify one or more object class instantiations that are associated by the program with a program state obtained during the execution of the program, may store in a file a description of the identified object class instantiations, where at least a portion of the execution of the program is simulatable based on the file, and may modify the first file in response to a user interaction with a graphical representation of one of the described object class instantiations, where a modified version of the portion of the execution of the program is simulatable based on the modified first file.

Abstract: Art editor within an integrated development environment displays a related file automatically. When a user enters a command to open a first file in the editor, the editor not only displays the first file's content (in a “primary editor”) but also automatically displays a second file's content (in a “related editor”), where the second file is related to the first file. In other words, when a first file is displayed in the editor, a file that is related to the first file is automatically displayed also. If the primary editor later displays a different file, then the file shown in the related editor will likely change as well, since the file shown in the related editor will be related to the “new” file in the primary editor. In other words, whatever is displayed in the related editor “tracks” whatever is displayed in the primary editor.

Abstract: The present invention extends to methods, systems, and computer program products for assigning type parameters. Embodiments of the invention permit using a visual editor to edit arbitrary object instances in a graphical fashion. Instances of generic types can be manipulated to change the type parameters for that generic (to be able to change a List<Customer> to a List<Product>, for instance).

Abstract: System and method for executing a graphical program on a first computer and providing a user interface of the graphical program on a second computer, where the graphical program includes a plurality of interconnected function icons representing graphical data flow of a function. Information indicating a plurality of graphical programs on the first computer, e.g., a list, may be displayed on the second computer, and user input specifying the graphical program on the first computer received to the second computer, e.g., selecting the graphical program from the list of graphical programs. The graphical program is executed on the first computer, and information describing the user interface of the graphical program is provided to the second computer during execution. The user interface of the graphical program is displayed on the second computer, facilitating interaction between a user of the second computer and the graphical program executing on the first computer.

Abstract: Aspects of the subject matter described herein relate to deployment scripts. In aspects, in conjunction with creating a package for deploying software to a target, an installation script is also created. The installation script includes instructions for deploying the software in the package to one or more targets. The installation script is human-readable and readily modifiable. A software development tool may provide a seamless interface that allows a software developer to view, edit, execute, and debug the installation script on a local or remote target.

Abstract: A method, a system and a computer program product for hierarchical program source management retrieve a main program from a memory and initiate a layer representing a portion of the main program for editing on the display. Program code is edited within the layer in response to detected user programming inputs. A layer abstract syntax tree corresponding to the edited program code is generated. The layer abstract syntax tree is compared with a main program abstract syntax tree and a layer file is generated including the differences between the layer abstract syntax tree and the main program abstract syntax tree.

Abstract: An automated tool for partitioning the source code of a software system at heuristic architectural boundaries identified by a bug-reporting process, and for representing the architecture of the software system as a set of visual attributes without constraining the representation to any particular predefined architectural style. The attributes are visualized applying multi-dimensional mapping techniques to software components to generate visual maps of the relationships and interactions among software components that cannot be easily understood or assimilated in a non-graphical form.

Abstract: A system and method for refactoring one or more call sites based on a revised signature. If the original call site is ordered, the refactored call site is generated by sorting the arguments based on the revised signature. Each unnamed argument is selectively changed to a named argument based on whether it is preceded by a named argument and whether its index value matches the index value of its corresponding parameter in the revised signature. If the original call site is unordered, the arguments preceding the first named argument are ordered. New arguments corresponding to new parameters are added and selectively made to be named arguments. New optional arguments may be included or omitted from the refactored call site.

Abstract: An identification of a multi-component development artifact to be shared is obtained in a development environment. A remote receiver with whom to share components of the artifact is designated. Components of the artifact are shared with the remote receiver by automatically locating the components and sending the located components in a package with associated type descriptions. After the package is received, a check for conflicts is made, and acceptable components are merged into the local development environment.

Abstract: Initial source and target models are divided into segments responsive to at least one segmentation rule. After changes, post-change source and target models are likewise divided. The at least one segmentation rule is defined responsive to at least one transformation rule such that use of the at least one segmentation rule divides initial source and target models into corresponding segments. Change statuses are identified regarding initial segments relative to post-change segments of the respective models responsive to comparing initial segments to post-change segments of the source model and initial segments to post-change segments of the target model. An indication of conflicts between the post-change source model and post-change target model is generated for presentation to a user or to a computer automated conflict settlement process. The generating is responsive to comparing the identified change statuses of the corresponding segments of the initial source model and initial target model.

Abstract: An embodiment provides a system and method for updating a speech recognition program. The system provides a speech recognition program, an update website for updating a speech recognition program, and a database for storing data that may be used to update a speech recognition program. A user may utilize an update website, to add, modify, and delete speech recognition program information that may include: speech commands, dll's, multimedia files, executable code, and other information. Speech recognition program may communicate with update website to request information about possible updates. Update website may send a response consisting of information to speech recognition program. Speech recognition program may utilize received information to decide what speech commands, dll's, multimedia files, executable code, and other information it may want to download.

Abstract: A code cell is selected from a program code. The code cell is a contiguous subsection of code. To select the code cell from the program code, a first indicator is placed in the program code prior to the beginning of the code cell and a second indicator is placed in the program code after the end of the code cell. The code cell is edited to obtain an edited code cell. The edited code cell is analyzed, without saving the program code, to produce a result. The result is provided.

Abstract: Aspects of the subject matter described herein relate to remote project access. In aspects, project data for a project that is hosted on a server is provided to a client for use in a development environment of the client. A development environment may be instantiated and configured to allow a user to interact with the project as if the project existed solely on the client. Components on the client and server take care of transferring data and messages to and from the server to ensure that the user experience is seamless.

Abstract: A system and method for providing a completion list associated with computer program source code and a dynamic expression. A static analysis is performed to find and aggregate one or more candidate types of the expression. The analysis may include one or more of a number of techniques, including analyzing expressions that are assigned to a program variable, following method calls, examining system or other specified assemblies, loading runtime assemblies, or making inferences based on other uses of the variable. A dynamic analysis may be performed and combined with a static analysis. A completion list may be filtered or ordered based on a configured criteria.

Abstract: A development environment tracks code sections which have been copied and pasted into a code module from a source code section which has not been subjected to certain verifications. In one aspect, if an error in a copied section is later found during a verification process, the programmer is allowed to perform a multi-edit operation, whereby an edited change to a single copy is automatically propagated to multiple copies. In another aspect, the programmer is warned when copying and pasting a code section which has not been verified. Preferably, verification is performed in the process of compiling source into executable object code.

Abstract: Disclosed is a method and system for retrieving a software object based on a query and customizing a metadata of the software object by adding a property, a property value, a search key and a search key value to the metadata. An index is created on the software object based on the search key value and the metadata and the software object is persisted.

Abstract: A system and method for creating a graphical program. A function block may be displayed in a graphical program. The graphical program may include a plurality of interconnected blocks which visually indicate the functionality of the program. Additionally, the function block may be operable to perform a first function and may include one or more inputs and one or more outputs. User input specifying an attribute behavior for the function block may be received, e.g., via a menu which allows selection or definition of attribute behaviors, a graphical wizard, or another graphical program, among other methods. The attribute behavior specified for the function block may be usable to determine at attribute of at least a subset of the one or more outputs of the function block based on an attribute of at least one of the one or more inputs to the function block.