Abstract: In an ASP server farm, requests to use an application are directed to a particular executing instance of the application (or an appropriate component thereof) that is identified as being the least loaded of the available such instances of the application or its component. The number of such instances is dynamically increased or decreased in response to the number of requests for the application or components thereof. Requests may be directed (in accordance with the first aspect) or the instances adjusted (in accordance with a second aspect) on a per client-basis, in which instances of the application and/or components thereof are reserved for the use of a user or a particular group of users. Operation in this manner facilitates compliance with service agreements with respective users or groups of users.

Abstract: Programming code, such as dynamically loadable program code used in object oriented programming languages, may be pushed over a unidirectional communication link, such as though a transmitter tower transmission or one-way networking communication protocol. A manifest is created that includes identifiers of programming code that will be pushed onto the unidirectional communication link, where the manifest includes a push schedule. A receiver of the manifest retrieves pushed code of interest according to the schedule. Purchasing data may also be included in the manifest. Programming code may include decryption techniques to allow for pay-per-use retrieval of premium content.

Abstract: A method of managing information in a distributed system context including a local system and a remote system and using a remote invocation method of the JAVA language, said language including instructions and enabling creation of objects from classes having hierarchical relations between them, which method includes defining in the local system classes replicating a hierarchy of classes of the remote system and including means of access to said classes of the remote system in order to enable use in the local system of instructions specific to classes defined in the remote system.

Abstract: A system and method is provided for providing security to components or assemblies employed by application programs during runtime. The present invention employs digital signature keys to ensure that an assembly name that is published is unique because the assembly is published with a publisher's public key. This prevents others from publishing an updated version of an assembly that claims to be published from the same publisher. The present invention guarantees name uniqueness and prevents name spoofing because the original publisher is the only one with the private key matching the public key related to a published assembly. Due to the fact that the public keys are stored in each reference, the caller can be assured that the assembly that the caller is binding to at runtime comes from the same publisher that owns the private key.

Abstract: In a cluster of computing nodes having shared access to one or more volumes of data storage using a parallel file system, a method for managing the data storage includes selecting a first one of the nodes to serve as a session manager node, and selecting a second one of the nodes to serve as a session node for a data management application. A session of the data management application is created on the session node by sending a message from the session node to the session manager node, causing the session manager node to distribute information regarding the session among the nodes in the cluster. Responsive to the information distributed by the session manager node, events are received at the session node from the nodes in the cluster for processing by the data management application.

Abstract: When using a common configuration data structure (e.g., “registry”), the access redirector and entry reflector promotes compatibility and interoperability between differing versions of program modules. The access redirector redirects selected accesses to storage locations (i.e., “nodes”) of a common configuration data structure. The selected accesses are redirected to another node. This redirection stores configuration information for differing versions of program modules at different nodes. However, the differing versions are unaware that they are accessing different nodes. As configuration information in a node is changed, the entry reflector may copy selected portions of such changed information into its associated “reflected” node and vice versa. This reflection allows associated “reflected” nodes to share relevant configuration information that promotes interoperability.

Abstract: A method, system and infrastructure that allow an application to run with specified versions of assemblies bound thereto, while allowing the application author, assembly publisher and/or an administrator to change the originally-specified version as desired. Each assembly may exist and run side-by-side on the system with other versions of the same assembly being used by other applications. An application manifest specifies any desired assembly versions, which may be redirected to another version (overridden) by an application configuration. A publisher configuration provided by an assembly publisher can similarly override the specified version. Lastly, an administrator configuration is capable of overriding other configuration versioning information. A table built from the manifest and any configuration redirection may be accessed during execution to quickly locate the appropriate version.

Abstract: A method for updating code includes receiving an update command for a first program resident in a first code space including at least one segment, transferring program control to a second program executing in second code space including one or more segment, selecting one of the at least one segment, mapping the selected segment to data space and writing the selected segment. A method for detecting corrupt software code includes defining a correlation rule for a program that includes at least one segment that includes multiple markers. The correlation rule defines a relationship between two or more of the markers. The method also includes writing the program to a memory device, reading two or more of the markers from the memory device, determining whether a segment is corrupt by applying the correlation rule to the two or more markers and indicating whether the segment is corrupt based upon the determining.

Abstract: Systems and methods are disclosed for preparing program code for a first computer, wherein the systems and methods are implemented on a second computer. The systems include a relocating module that is adapted to relocate program code by modifying locations in the program code identified by location data. The modifications made by the relocating module are based on a memory address. The systems operate on program code for the first computer, where the program code is stored on the second computer. The relocating module is provided the memory address that identifies a memory location in the first computer. The memory address is suitable as a basis for modifying the program code. The relocating module is also provided with location data that identifies locations in the program code to be adjusted based on the memory address.

Abstract: A system is disclosed with a method for extending the appearance, functionality and/or the content of an application, such as an administrative console. In accordance with one embodiment, the invention provides a system comprising a first application that includes content which controls the appearance, content, and/or function of said first application, and a second application that includes additional content stored therein, together with an extension or alternate means for adding, and registering said second application with said first application. The content of the second application is then used to modify or extend the appearance, content or functionality of said first application.

Abstract: A program-changing method for a network having at least two nodes that include a first and a second predetermined node, each network node having a program, includes a network management system connected to the first predetermined node of the network. New changing program data and a control signal are transmitted to the first predetermined node connected to the network management system which is disposed in the network separately from the nodes and configured to manage the changing of the programs in the nodes. The first predetermined node replaces its program with the new changing program data. The network management system transmits a program-transmitting-signal to the first predetermined node, causing the transmission of the newly changed program data stored therein to the next predetermined node to change the program of the next predetermined node under control of a respective control signal to the second predetermined node from the network management system.

Abstract: A method and system for dynamically linked emulation with a mix of target debuggers on a host computer wherein a debugger for each processor on the target system connects to a target interface for that kind of processor. That target interface then communicates with an emulator dynamic loader on the host computer connected to an emulator. The target interface communicates with the dynamic loader on the host computer to determine if there is support for the desired kind on the emulator. If not a target interface is loaded to the emulator and connected to the already running software on the host. A connection to this target interface software on the emulator is then provided to the host computer.

Abstract: Initially, “libraying” text is inserted on all scripts executed on the computer, allowing administrators to discern at a glance every script that has been executed. Furthermore, administrators can easily ascertain the results of all automatically run programs (such as overnight batch jobs) by looking in a common location rather than all over the computer. All scripts installed on a computer system are required to have the ability to generate uniform output. This output includes the script name, the time it was run, the user name and the script execution results. When a script is executed, it will write this detailed output into a predefined directory. There, a file is generated which lists all the parameters associated with the script execution. The parameters are then available for future review by administrators. Additionally, an executed script writes a summary output to a common file. This file provides a single point of reference and further provides a summary description for all activities.

Abstract: The present invention provides a visual linker. The visual linker includes a link server that implements linking instructions for sections to a memory. The visual linker also includes a graphical user interface that receives said instructions and displays said sections within said memory. The visual linker also includes an application programming interface that receives said instructions and reports the results of said linking instruction and said sections within said memory. The visual linker also includes an incomplete link comprising sections not allocated to said memory. The visual linker also includes a link recipe comprising said instructions implemented by said link server.

Abstract: Methods and apparatus for managing execution of an application according to an application lifecycle. The application lifecycle is managed by an application manager through a set of commands that enable the application manager to cause the application to enter one of a plurality of states. In addition, the application can communicate with the application manager to indicate that the application cannot change its state as the application manager has requested or to request that the application manager change the state of the application to a particular state.

Abstract: A system and method for providing dynamic references between services in a computer system which allows a first service (e.g. an application program running on a client computer in a local environment) to gain reference to a second service (e.g. a service running on a server computer in a distributed environment) without requiring knowledge of how to find the service or a particular version of the service on a distributed computer network. In a particular embodiment disclosed, when a getService method is called, a reference back to an instance of the service is returned and an implementation of a service connector interface encapsulates the logic necessary to lookup an instance of a specific service and return a reference to that service. In this regard, developers of a service may write, or program, a module that adheres to a service connector interface.

Abstract: A method and apparatus for managing a run-time environment is provided for improving performance and scalability of networked computer systems. In one example of the invention, a method starts by loading a class file, the class file specifying a class that includes a static class variable and a static initializer to initialize the static class variable. The static initializer is then invoked to initialize the static class variable. The class and the initialized static class variable are then saved in a second class file. The second class file is then loaded into a shared memory, the second class file including the class and the initialized static class variable.

Abstract: Disclosed is a method for executing a remote method. Each argument of the remote method is wrapped when the argument is a remote object (e.g. the argument's declared class implements a remote marker interface). However, each argument of the remote method is copied when an argument is not a remote object. The remote method is invoked using the wrapped or copied argument(s) (e.g. the wrapped or copied arguments are passed to the invoked method). A result of the invoked remote method is then wrapped (e.g., prior to being passed to the process that is receiving the result) when the result is a remote object (e.g., the result's declared class does not implement the remote marker interface). In contrast, the result of the remote method is copied (e.g., the copy is then passed to the process that is receiving the result) when the result is are remote object.

Abstract: A computer system capable of system management from a terminal having a wireless communication function is provided with an IrDA-IF having an IrDA port capable of infrared wireless communication between the terminal and the computer system itself and a system management controller connected to the IrDA-IF, the system management controller performing the system management instructed by the terminal through infrared wireless communication with the terminal through the IrDA-IF.

Abstract: Committing data loaded on a device includes computing a program unit storage commitment fingerprint over a program unit if the program unit is finally loaded in a non-volatile memory on the device, associating the program unit storage commitment fingerprint with the program unit and storing the program unit storage commitment fingerprint.

Abstract: A system facilitates configuration of at least one of multiple network devices (130) of different types. The system includes a configuration database (310), a policies database (320), a configuration generator (330), and a protocol engine (340). The configuration database (310) stores data that defines a configuration for the network device (130). The policies database (320) stores rules for configuring the network device (130). The configuration generator (330) generates a deployable configuration from the data in the configuration database (310) and the rules in the policies database (320). The protocol engine (340) deploys the deployable configuration to the network device (130).

Abstract: The present invention discloses a technique for sharing data between at least two operating systems. In accordance with the present invention, a volume is provided in a data storage device. The provided volume is a portion of memory within the data storage device. The provided volume is accessible by a source operating system residing on a source computer and a target operating system residing on a target computer. Data is generated within the provided volume using the source operating system. The generated data is in a format that is readable by the target operating system.

Abstract: Methods for converting from a COM interface pointer to an underlying C++ object are described in various embodiments. In the various embodiments, classes are constructed in support of the underlying C++ object. The classes are used to enforce rules safely convert a COM interface pointer. One rule is that a COM interface to be converted cannot be marshaled. A second rule is that an object requesting the C++ object must have legal access to the COM interface (for example, the same execution unit). A third rule is that the object type of the COM interface must be in the inheritance hierarchy of the C++ object.

Abstract: A method of integrating an application in a computerized system for representing a real world object, and a system employing the method. The real world object may be any object, device, process or item of equipment, including equipment in industrial or commercial installation or process, in any location. The real world object is represented as an object, called a Composite Object, in a part of a computer program. The invention also includes Aspects which represent the data and/or operations of a Composite Object. The Composite Object is a container holding at least one Aspect representing data for the real world object. The Composite Object includes at least one interface for use by another object which interface is implemented by the Aspect System and accessed through an object Request Broker, that complies, for example, with COM. The principal advantage of the method and system is that applications within the system do not require prior information about other objects or applications included in the system.

Abstract: System and method for enabling user interface code to be encapsulated in a sub-program of a graphical program. A node referencing a user interface element of a graphical program may be connected to a node referred to as a “property node”. The user may configure the property node with information specifying which property or set of properties of the referenced user interface element to set or retrieve. When executed, the property node may utilize the reference provided by the node associated with the user interface element in order to interact with the element. The node referencing the user interface element may also be connected to a subprogram node. The subprogram is operable to receive the user interface element reference and pass the reference to property nodes in order to set or retrieve properties of the user interface element. The subprogram may have an associated user interface panel comprising a “reference control” for receiving a user interface element reference.

Abstract: A distributed computer application can be made to communicate with a plurality of computer architectures. A first compiler compiles and converts input interface source code to produce a high level language including a plurality of computer architecture interfaces. A second compiler integrates application source code with the converted interface source code to produce the distributed computer application with the plurality of computer architecture interfaces that enable the distributed computer application to communicate with the plurality of computer architectures.

Abstract: Supervisor apparatus for running an integrated operation on a plurality of applications distributed on networked stations, the apparatus comprising: an evaluating unit for receiving and evaluating output from at least two stations including a first station and at least one other station, and an operating unit for sending selected commands to a first application running on said first station, said commands being selectable according to rules, said rules specifying a dependency of a command to be sent to said first station upon an evaluation of output from said at least one other station. The apparatus is useful for carrying out integrated functionality or regressive testing of multi-station single or multiple processes.

Abstract: A management system communicates with at least one remote data processing system, associated with a trading participant, on a technical parameter of at least one remote data processing system. A technical parameter may refer to software configuration data, hardware configuration data, operational status of a data processing system, operational status of a software component of the data processing system, operational status of a hardware component of the data processing system, or otherwise. The management system receives a report message on the technical parameter via a communications network. The management system interprets or processes the report message for a presentation on a user interface of the management system.

Abstract: A diagnostic service system includes a networked electronic device that can self-determine a need for technical support, initiate communication with a technical support system, and provide information corresponding to the need for technical support to the technical support system. The technical support system receives the information and compares the information with an information database to determine a solution, or solutions, for the electronic device in accordance with the received information. The electronic device receives the solution, or solutions, from the technical support system and implements the solutions to resolve the need for technical support in the electronic device, or renders instructions for user interaction with the electronic device to implement the solution.

Abstract: A method and apparatus are disclosed for programming software components that treats software components as the basic unit of abstraction and computation. A software component is encapsulated and classes and other program entities, such as data fields and methods, within a given component do not exist beyond a component boundary. A component interacts with other components only by means of a defined set of input and output ports. A component can inherit and implement ports declared in a template and can declare and implement new ports. A component can only access the external environment through its output ports. An output port of one component can only be connected to a conforming input port of another component. A connect statement is an explicit plumbing operation for connecting components together. Interactions between components are loosely coupled. A related set of templates can be grouped together to form a group. Groups are useful for implementing implicit invocation and multicasting.

Abstract: The present invention provides a method and apparatus for the creation of software applications that enable the interaction between a mobile business user with a wireless device or handset to interact with functions and information stored in a remote networked server. The wireless device may use either a micro-browser application, which supports some known markup language, or a more powerful “smart” or thick client application. The interaction between device and server is facilitated by wireless infrastructure and middleware (which could include the ThinAir Server™). The server supports the storage and retrieval of data either through some direct access method such as Structured Query Language (SQL) or a more complicated programmatic interface. Through the use of a software development kit and specific techniques and methods described, a software developer can create effective, efficient wireless applications which employ the components mentioned above.

Abstract: Network signalling apparatus and methods use at least an SCCP protocol layer of Signalling System number 7 (SS7) and other protocol layers. The SCCP protocol layer supports connectionless and connection-oriented protocol services, and network management procedures are carried out on a per protocol service basis, that is, network management procedures at SCCP are independently treated for connectionless and for connection-oriented protocol services.

Abstract: A system for utilizing an object library to dynamically match the type structures of a client and a server to determine compatibility. Once compatibility has been established, the client and server may communicate through a secure connection. Information may be sent asynchronously between the client and the server, and a flow control provides a buffer at the flow origin to ensure that there is no overflow of information to the recipient of the flow.

Abstract: The present invention provides a method, apparatus, and medium for adding text and text-based components to a Web page hosted on a server. A control, which is run at the designing time of the web page (design-time), when implemented, writes HTML information to a created web page. The created HTML information may include text and other text based components (client and server scripting, applets, ActiveX controls, JAVA scripting, and other components). Through the use of OLF, the controls incorporate author-friendly capabilities including in-place editing, property sheets, and persistence. Through the use of these controls, authors may automate the web page generation process and eliminate redundant coding.

Abstract: A programming apparatus having an arrangement for formulating an automating task to be performed in the form of a programming language for automating apparatuses is described, which simplifies a process error analysis for an analysis unit. For this purpose, the programming apparatus is provided with an arrangement that store operands (9; 27), marked to be monitored, in the order in which they appear in the network in a logic list. Furthermore, the programming apparatus has an arrangement that store the operands of this network in an operand list in the order in which they appear in the network. The lists can be transferred into the analysis unit for analysis.

Abstract: The present invention is a software generating device for generating new software by a plurality of modules. This device includes an extraction unit analyzing specifications of software to extract necessary modules, and a retrieval unit checking whether the modules are stored in our own device and for executing a retrieving process of the modules for another device connected through a network if the modules are not stored in our own device. For this reason, modules held by the other device can be used through the network.

Abstract: A system is disclosed for benchmarking data transfers using different transport mechanisms between processes run on various nodes of a network. A central manager component interfaces with a user and reports benchmark results, and an agent component under control of the manager component is provided on each of the nodes. The agent components conduct the benchmarking tests under instruction from the manager component and report the results to the manager component. The manager component may enable the automatic reproduction of tests through a repository of logged scripts. The invention provides a simple to use and centralised control of testing, with measurement techniques independent of reporting. The framework is extensible to the benchmarking of new transport mechanisms, and allows testing of Inter-node transfers and Intra-node transfers through the same interface.

Abstract: A system for creating a custom environment for executing application programs in a target device. The system broadens the applicability of software environments like Java by providing custom pre-loaded classes for application programs and by customizing the procedures for class loading to the available resources in the target device. The system includes tools for generating a pre-load class list that specifies a set of classes needed to support the application program. The tools build the custom environment including a set of code for a virtual machine and a set of code for each of a set of pre-loaded classes specified in the pre-load class list. The virtual machine loads classes from the pre-loaded classes, a file system class library, and/or a networked class library using widely available network protocols.

Abstract: An apparatus and method for incrementally performing a remote loading is disclosed. The incremental remote loading apparatus includes dependent reader modules for analyzing the object file according to a object type and detecting an independent linking information and independent linker module for receiving a detected liking information, downloading the object file to a target system and rearranging target modules of the target system. The present invention provides convenience to developers by linking object files to the target system without following a linking order and reduces a development time by changing a dependent environment without changing whole developing environment and reduces communication time by recognizing various object file type and partly loading/unloading related modules to target system.

Abstract: A computer file update or patch process involves building a Patch File. The existing or original file (the OLD file) and the revised file (the NEW file) are input into a Patch Build program. The differences in the OLD file and the NEW file are determined by the Patch Build program, and this information is output by the Patch Build program as a Patch File. The Patch File is distributed, along with a Patch Apply program, to end users so that the OLD file is efficiently converted to the desired, updated NEW file. The OLD file and the Patch File are input by the end user into the Patch Apply program. The Patch Apply program changes, at the bit level, only the portions of the OLD file required to yield the desired file update. By distributing only the Patch File and Patch Apply program to the end users, the desired file update can be implemented by the end user with maximum operational and economic efficiency.

Abstract: Systems and methods are disclosed for preparing program code for a first computer, wherein the systems and methods are implemented on a second computer. The systems include a relocating module that is adapted to relocate program code by modifying locations in the program code identified by location data. The modifications made by the relocating module are based on a memory address. The systems operate on program code for the first computer, where the program code is stored on the second computer. The relocating module is provided the memory address that identifies a memory location in the first computer. The memory address is suitable as a basis for modifying the program code. The relocating module is also provided with location data that identifies locations in the program code to be adjusted based on the memory address.

Abstract: A software package manager uses a distribution unit containing components for a software package and a manifest file that describes the distribution unit to manage the installation, execution, and uninstallation of software packages on a computer. Information in the manifest file pertaining to a software package is stored in a code store data structure upon installation of the package. The manifest file also contains information that permits the software package manager to resolve any software dependencies upon installation. The software package manager uses the code store data structure to locate the required components when the software is executed and to remove the components appropriately when the software is uninstalled.

Abstract: A linkage editor executing at a server receives instructions for packaging software components that are required for program execution at a client. The linkage editor generates an output file by iteratively analyzing the program for references to other software components and extracting those components from their parent classes. The linkage editor sends the completed output file to an interface task, which transmits it to the client.

Abstract: A method of controlling an application program that communicates information over a network (32) between a client (34) and a server (20) is provided. The application program has a previous state and a current state. At least two methods (24) are stored on the server (20). At the server (20), a request having a state indicator indicative of the previous state of the application program is received. One of the methods (24) is selected based upon the state indicator. Then, the requested method (24) is transmitted to the client (34).