Abstract: A system for updating active client positions can include a platform for managing active application components; a configuration server for storing updates; and, a configuration client for receiving updates from the configuration server and communicating the received updates to the platform. The platform can receive the updates from the configuration client. Subsequently, the platform can terminate selected ones of the active application components. Then, the platform can apply the received updates to the terminated application components. Finally, the platform can reload the updated application components.

Abstract: A method and system for processing object property changes are provided. A request to process at least one object property is obtained and a property change defer cycle is started. The object property change is grouped into one or more object property change groups. In the event the object property groups implementation creates additional property changes, the additional property changes are grouped and then implemented. The property change defer cycle is terminated and the object property groupings are implemented.

Abstract: Data is migrated by moving a set of the data in a data storage system of a computer system. The method includes monitoring a performance of at least one executing application while moving the data in the data storage system. A change in the rate of moving is calculated in response to the monitored performance of the executing application. The rate of moving is modified in accordance with the calculated change.

Abstract: A topological best match naming convention apparatus and method for graphical user interface (GUI) testing are provided. With the apparatus and method, properties of the GUI object are recorded and stored in a GUI object database. During execution of test scripts, if a lookup of an GUI object's name to its runtime control fails, the present invention attempts to perform a match with the currently known objects. The matching mechanism is based on a comparison of the properties of the GUI object to properties of known GUI objects. With this mechanism, a predetermined set of properties is collected from the GUI object that is subject to the test script and for which the lookup of the runtime control failed. Each property of the known GUI objects in the GUI object database is assigned a weight based on the probability that a GUI object having a matching property is the same GUI object.

Abstract: A method and system for organizing nodes within a program tree. The system allows various child node categories to be defined for node types of a program tree. When a child node is added to a parent node, the system identifies the category of the child node. The system then instantiates a category data structure for the identified category. The system stores a reference to the instantiated category data structure in the parent node and stores a reference to the child node in the instantiated category data structure.

Abstract: A mechanism for testing execution of applets with plug-ins and applications is described. In one embodiment, a data structure that specifies at least two applets of a plurality of applets is accessed. Based on the data structure that specifies the two applets, a plug-in that executes with an application is caused to attempt to execute each of the two applets. After causing the plug-in to attempt to execute the two applets, results are generated based on the attempt to execute each of the two applets. The mechanism may be implemented to test multiple test suites that each comprise one or more test cases that each include an applet, and reports may be generated for individual test cases, test suites, or a set of test suites. This embodiment of the present invention minimizes the time required for testing and allows for testing the effects of applets that are not visible to a user.

Abstract: A multi-lingual tag extension mechanism suitable for use with the JAVASERVER computer software Pages platform. Rather than creating a closure abstraction, the present invention “in-lines” a body evaluation for the tags. A doStart ( ) method processes a start tag and determines if a body needs to be evaluated. If so, a body evaluation buffer is passed to a doBody ( ) method for body evaluation. Once the body evaluation is complete, a doEnd ( ) method completes the processing by synchronizing the variables. The scripting details of the present invention match any nesting of the tag, so the at the structure corresponding to the original scripting is preserved. Furthermore, the present invention is not dependent on the specifics of the scripting language used to form the Web page.

Abstract: A central processing unit (CPU) including an operating system for executing code segments capable of performing graphics processing on the CPU. Associated therewith is a graphics application specific integrated circuit (ASIC) for performing graphics processing in accordance with a graphics processing standard. An extension to the software is included that identifies a first portion of the graphics processing to be performed on the graphics ASIC and a second portion of the graphics processing to be performed on the CPU. Such second portion of the graphics processing includes application-programmable vertex processing unavailable by the graphics ASIC. A compiler compiles the software to execute the first portion of the graphics processing on the graphics ASIC and the second portion of the graphics processing on the CPU in accordance with the extension.

Abstract: Described is a system and method for dynamically modifying an executing heterogeneous program in a heterogeneous distributed computing environment. A system reference is obtained to a target system on which the heterogeneous program is executing. The target system may be a local or a remote system. Based on the system reference, a program reference associated with the program is obtained which is used to locate a component of the program. An executable code associated with the component is modified to create a modified executable code based on a modification of an internal representation of the component. The modified code is inserted into the target system memory without requiring the target system to go offline. The code is inserted either by patching over an original memory area or injecting into a new memory location. The code may be inserted when the target program is operating in user mode or kernel mode.

Abstract: A graphical programming interface for use in developing computer programs providing computational decision-making capabilities. The interface uses a structure of graphically displayed positions, arguments and linkages to enable the development of computational decision making programs. The positions are primarily characterized by position values that may represent outputs although they may have a variety of other function features such as thresholds. The arguments are characterized by argument values that may represent inputs. The arguments are associated with particular positions and the values of the arguments associated with a given position are combined to determine the value of that position. The linkages extend between different positions and arguments and define different types of functional relationships between them.

Abstract: This patent describes a method of compiling a computer program from a sequence of computer instructions including a plurality of first, set branch, instructions which each identify a target address for a branch and a plurality of associated second, effect branch instructions which each implement a branch to a target address. The method comprising the steps of; reading the computer instructions in blocks; defining a set of target registers associated with each block for holding target addresses for the set branch instructions in that block; defining as a live range of blocks a set of blocks for which a target address of a particular set branch instruction is in a live state; and using the set of target registers and the live range to ensure that target registers holding target addresses in a live state are not available for other uses.

Abstract: A method of forming an executable program from a plurality of object code modules where each object code module includes a plurality of relocation instructions having at least one information output relocation with a field indicating information to be output. The method includes reading a relocation instruction from one of the object code modules and, when the read relocation instruction is an information output relocation, displaying the information indicated in the field in a human readable form.

Abstract: A first software program is capable of being referenced by a second software program. For compiling the second program, information, including an interface definition, is generated by a converter for the first program. Also, a generator is provided for generating first source code from the interface definition, so that second source code may be developed and the second program may be compiled from the first and second source code.

Abstract: A method and system for debugging a computer program are described. In one embodiment, information pertaining to a first function executed within the computer program is presented in a first sub-window of a stack window. Further, information pertaining to a second function executed within the computer program is presented in a second sub-window of the stack window. The second sub-window is positioned next to the first sub-window to provide a horizontal arrangement of the sub-windows within the stack window.

Abstract: A method for generating source code objects has steps of generating a translation file containing translation logic; inputting the translation file into a code generator; and generating translation source code as a function of the translation file. A system for accessing a database through a translation layer comprising a first database; a translation layer, defined by translation source code; and an application for accessing the first database through the translation layer.

Abstract: A workflow code generator for generating executable code for multi-channel and/or multi-modal applications. The code generator may include a parser for reading application input files and creating internal representations of declarative statements within the input files. The code generator may further include a model analyzer, which processes the internal model to detect errors, perform optimization, and prepare for outputting the result. The code generator uses a symbol or mapping table for storing references to resources that have been used by the input application. The code generator assigns code fragments to object patterns, resolves data object references by referring to mapping table, and traverses the objects and emits code assigned to the objects.

Abstract: A universal routine is controlled through a user interface, or through an engine command processor when using a recorded file, and implements logical operations for reviewing and testing objects in the program. Through the user interface the reviewer selects objects to be exercised and exercises them with selected methods and parameters. The object under review is cocreated so that the cocreated object is exercised. The reviewer selects parameters, if any, for use by the selected method in the object when the selected method is invoked. The selected method on the object is called; the parameters for the method are retrieved and the method is invoked. In effect the object under review is sent a message containing a selected method to be performed with selected parameters. The result of exercising the object with the selected method and selected parameters is logged for review. A dialog between the user/reviewer and the objects under test continues until all objects to be reviewed have been exercised.

Abstract: The invention relates to methods and apparatus suitable for executing a service or application at a client peer or client side, having a client specific device or client specific platform, with a reconfigurable architecture, said service or application being provided from a service peer or a service side. In a first aspect of the invention, the method comprises transmitting to the client peer from the server peer an abstract bytecode. The abstract bytecode is generated at the service peer by performing a compilation of an application. The abstract bytecode includes hardware bytecode and software bytecode. At the client peer, the abstract bytecode is transformed into native bytecode for the client specific device.

Abstract: A system and method for discovering the design time attributes of a component are provided. The invention includes a type descriptor that can access metadata associated with a component and report the metadata to a development tool. The invention further includes a custom type descriptor interface that can be implemented on a component in order to dynamically provide information regarding the component to the type descriptor. The invention further includes a type descriptor filter service interface that can be implemented by the development tool to facilitate filtering of design time information regarding components in order to simulate a run time environment. The invention further comprises methodologies and tools for facilitating application development.

Abstract: A method for implementing an object model for an object-oriented programming language. Also contemplated is a method whereby some object state is materialized directly in those objects deemed likely to use such a state, but is externalized for those objects deemed unlikely to use the state.