Abstract: An electronic device with a handoff agent is capable of coordinating the update by one or more update agents in the electronic device. The handoff agent is capable of selectively updating an application software or firmware that is stored in non-volatile memory that may employ multiple FLASH chips, the handoff agent employing appropriate update agents, that each employs appropriate subsets of an update package that has been retrieved from an external system.

Abstract: A system and a method are provided to quantitatively analyze the risk for a risk-based testing of software having at least one module. The risk-based testing comprises obtaining behavior of each module to a set of test cases. The method to quantitatively analyze the risk comprises assigning a confidence weight to each test case for each module based on its test history, assigning a confidence weight to each of a plurality of software specific parameters for each module, calculating a raw confidence level for each module based on the assigned confidence weights to the test cases, and calculating a confidence quotient for each module as a weighted sum of the raw confidence level for each module and the confidence weight for each software specific parameter. The confidence quotient indicates the risk of defects in each module. The module with the smallest confidence quotient is assigned the highest priority during the testing of the software.

Abstract: A system and to prevent data corruption due to split brain in shared data clusters includes two or more nodes of a cluster, a shared storage device, and an update manager. The update manager may be configured to maintain a local persistent store corresponding to each node of the cluster. On receiving an update request directed to the shared storage device from a first node, the update manager may be configured to redirect the update to the local persistent store corresponding to the first node. The update manager may be further configured to verify a cluster membership status of the first node, and to transfer the contents of the update from the local persistent store to the shared storage device if the cluster membership verification succeeds.

Abstract: Techniques for delaying the installation of an application are presented. An installation is downloaded to a portable device. The installation is associated with an application, which is to be loaded onto the portable device. The installation is delayed after download and is processed on the portable device when an alarm is raised indicating that the application is to be loaded on the portable device.

Abstract: A combination structure node is provided by a graphical programming development environment for use in a graphical program, where the combination structure node is operable to perform two or more control flow functions. For example, the combination structure node may be operable to perform two or more of: iteration, looping, conditional branching, sequencing, timed execution, event-driven execution, or other control flow functions. A user may include the combination structure node in a graphical program and associate a graphical code portion with the combination structure node. During execution of the graphical program, the combination structure node is operable to cause the associated graphical code portion to execute according to the two or more control flow functions performed by the combination structure node.

Abstract: A system and method of detecting redundant subroutine calls in a software system is provided. Call path data is obtained for the software system and stored into a call tree comprising a plurality of nodes, each node representing a software routine of the software system, the call tree describing the calling paths between the plurality of software routines. At least one focal node is identified among the plurality of nodes in the call tree for redundancy analysis. The calling redundancy to the focal node is analyzed by determining a common ancestor node list for the focal node and by generating call path data for each of the common ancestor nodes on the list. The common ancestor list data may be sorted and call trees generated for the common ancestors in relation to the focal node. This data may then be displayed on a graphical user interface for redundancy analysis of the focal node.

Abstract: Embodiments of the present invention provide the ability for a software provider to distribute software updates to several different recipients utilizing a peer-to-peer environment. The invention described herein may be used to update any type of software, including, but not limited to, operating software, programming software, anti-virus software, database software, etc. The use of a peer-to-peer environment with added security provides the ability to minimize download time for each peer and also reduce the amount of egress bandwidth that must be provided by the software provider to enable recipients (peers) to obtain the update.

Abstract: Techniques for simulation of multi top-level graphical-containers (e.g., frames) in an object-oriented computing environment are disclosed. A Multi Top-level Graphical-Container Simulator (MTGS) can be provided to simulate multi top-level graphical container support for applications that expect to use a plurality of top-level graphical containers (e.g., frames, windows). A MTGS may be implemented as a layer between a GUI-based application and an operating system and/or hardware/device with limited or virtually no graphical support capability. The Multi Top-level Graphical Simulator (MTGS) can effectively isolate the operating systems and/or hardware/device from the GUI-based application, and yet hide this simulation from the operating system and/or hardware/device. MTGS may be implemented in a platform independent programming language (e.g., Java™ programming language using a set of Java™ classes which have been provided in the Java™ Swing development toolkit.

Abstract: A method for monitoring the execution of a program executable on at least one microprocessor of a micro controller using a debug logic of the micro controller, with an exception, particularly an interrupt of the program execution, being triggered by the debug logic upon access to a specific address range during the program execution time. In order to provide monitoring of the execution of a program, executable on a microprocessor, for faults, which is particularly reliable yet conserves resources as much as possible, it is suggested that the debug logic be configured by the microprocessor and that an exception routine be executed by the debug logic after an exception has been triggered during the program execution time. The debug logic is advantageously configured during the startup of the micro controller. Preferably, the micro controller is reset and started up again and the monitored program is initialized during the execution of the exception routine.

Abstract: There are provided mechanisms and methods for enabling the deployment of applications into new execution environments by adding extensions to base deployment capability for each of the new containers. These mechanisms and methods can enable embodiments to instantiate modules that augment deployment and/or execution environments for applications being deployed. The ability of embodiments to provide augmented deployment and/or execution environments can enable server embodiments to become more flexible environments from the point of view of developers seeking to implement applications on the server.

Abstract: A server application discovers its relevant data objects and generates a report of the current states of such objects at a moment in time that is relevant to a detected failure. Responsive to a request for a server application state, the application can identify root objects; discover data types, values, and related objects through recursive traversal and analysis of the object hierarchies; and generate a state description of the application for review and analysis by others. The state discovery may be synchronized among multiple threads to ensure that the state description represents a snapshot of the server application state and a single point in its execution. The state description can be analyzed by validation tools to detect where the error might exist in the application and how the error might be corrected.

Abstract: An asynchronous programming language that facilitates concurrent programming by utilizing futures, asynchronous calls, and joins on futures. For each of a client interface and a service interface of an asynchronous interface, respective models are automatically extracted. A behavioral contract is defined on the asynchronous interface. The client and service models are then passed to modular checking algorithm that checks to ensure that both the client and the service conform to the behavioral contract. The checking algorithm combines region-based type systems with model checking techniques to handle pointer aliasing in a sound manner.

Abstract: Apparati, methods, and computer-readable media for preventing unauthorized installs and uninstalls of software modules on a computer. One method embodiment of the present invention comprises the steps of amending (41) an uninstall instructions file (32) to include an invention attribute (33) and at least one pre-selected uninstall condition (34); detecting (42) an attempt to open said uninstall instructions file (32); checking (43) the uninstall instructions file (32) for presence of said invention attribute (33); determining (45) whether the at least one condition (34) is satisfied; and aborting (46) the uninstall when at least one condition (34) is not satisfied.

Abstract: Modification of source code reduces a launch time associated with an application program so that the application program more quickly responds to input from a user after startup. One technique of modifying source code includes converting globally defined variables in the source code to local static variables associated with respective newly created functions. Inclusion of the globally defined variables in the source code impacts application launch time because a compiler creates initialization code associated with the globally defined variables that must be run at launch time to initialize the variables in case they are used by functions in the application program. On the other hand, local static variables are initialized when the function that contains them is first called. Thus, use of local static variables in respective newly created functions in lieu of globally defined variables reduce application program launch time.

Abstract: An integrated application setup enables the implementation of application customizations through patch technology. A customization patch extends a typical patch file format such that the customization patch serves as a container for application customization data useful for customizing an application using different underlying technologies. The contents of the customization patch can include transforms, cabinet files, and XML content containing customization information.

Abstract: Multiple versions of a runtime system, such as a software emulation application that emulates a legacy hardware architecture, are allowed to co-exist in the memory of a new hardware architecture. The operating system software of the new hardware architecture reads configuration data from a database or table to decide which version of the runtime system is desirable for an application program or game that is being loaded or is currently running, and, if a match is found, only that runtime system is invoked. To reduce storage footprint, the different versions of the runtime system may be stored using “differential patching” techniques. In this configuration, the operating system will always launch the same basic runtime system binary, but it will select a different differential patch to apply at run-time based on the title as determined during the database lookup.

Abstract: A method and system are described for migrating test scripts written for a current test tool (CTT) to a new test tool (NTT). A conversion tool sets the CTT in a playback mode and the NTT in a record mode. The CTT provides actions to an application under test (AUT) causing objects to be created and modified. The NTT monitors the actions of the CTT and creates a script to mimic the actions of the CTT. The current test script is modified to add comments, and translated using standard translation tools. Application-specific statements do not translate and are replaced with those previously created by the NTT in the record mode. This results in a script that performs the same functions as the original test script.

Abstract: A method to automatically replace computationally intensive functions with optimized functions in managed code is disclosed. If the underlying processor has associated optimized functions, managed application code is disassembled and parsed to find computationally intensive functions. The computationally intensive functions are then replaced with optimized functions, and the application code is re-compiled if necessary.

Abstract: Methods and apparatus, including computer program products, for matching software requirements against target system landscape descriptions and for applying rating metrics to intermediate results during the matchmaking process. Data are received as inputs describing the requirements and dependencies of a particular software application and the resources available in the target system that may be able to meet these requirements. These data are searched for combinations of system resources that will satisfy the requirements of the application as well as optimization metrics and other requirements supplied by the user. Once a match is found, it is given a rating and ranked against any other matches.

Abstract: A method of generating a filter graph of a development project is presented comprising identifying a plurality of source clips comprising the development project, wherein each source clip represents an access to a source, and combining two or more accesses for two or more source clips into a single access if the two or more source clips satisfy one or more criteria.