Abstract: A method and system for referring to and binding to objects using a moniker object is provided. In preferred embodiments a moniker object contains information to identify linked source data and provides methods through which a program can bind to the linked source data. A binding method is provided that returns an instance of an interface through which the linked source data can be accessed. In a preferred embodiment, the moniker object provides other methods including a reducing method that returns a more efficient representation of the moniker object; equality and hash methods for comparing moniker objects; and inverse, common prefix, and relative-path-to methods for comparing and locating moniker objects from other moniker objects. Several implementations of a moniker object are provided. Each implementation is a moniker class and has a class identifier that identifies code to manage the moniker class.

Abstract: The cache control unit 15 of the mobile terminal 10 receives an access request for an instance of an object that specifies data to which applications 13 refers, and in the case that an instance of the object does not exist, creates an instance of the object and a counter. In addition, an instance of a reference setting class is created, the reference that refers to the instance of the requested object is set and the result is returned to the application 13, and the counter is incremented by 1. In the case that a release notification for the instance of the reference setting class is received, the counter is decremented by 1, and when the counter has reached 0, the instance of the object is released.

Abstract: The present invention relates it directed to configurable collection of computer related metric data. A computer system generates computer related metric data related to an application. The application accesses a manifest that indicates a portion of the generated computer related metric data (e.g., a subset) is to be packaged for delivery. The application sends schema-based package start data to cause the portion of generated computer related metric data to be packaged. A quality metric module receives the schema-based package start data and accesses the indicated portion of computer related metric data. The quality metric module packages the portion of computer related metric data according to a packaging schema. The application sends a package send command to cause the packaged portion of computer related metric data to be delivered. The quality metric module receives the package send command and sends the packaged portion of computer related metric data in response to the package send command.

Abstract: A system and method providing status information about a task being processed on a computer system is described. The task comprises an operation that blocks user activity, such as a modal task. Status information about the task is obtained during processing of the task on an event thread of a computer system. A status display is generated based upon this status information. The task yields time on the event thread, enabling the status information to be displayed in the user interface of the computer system.

Abstract: A hybrid environment may be used for addressing application compatibility between a host operating system and one or more application(s) optimized to run on a different (“guest”) version of the host operating system. A thunking wrapper consisting of a native thunking layer, a service thunking layer, and a subsystem thunking layer provides translation between the guest application and the host operating system for a seamless interface. Multiple thunking wrappers may be included to support application compatibility between multiple guest operating systems and the host operating system.

Abstract: A facility for improving for performance of an initial user interface for a client-server application is described. The facility selects a proper subset of the user interface elements of the initial user interface. For each selected element, the facility generates a more efficient replacement for the selected element. The facility then generates a revised user interface that includes the unselected elements of the initial user interface, together with the generated replacements for the selected elements of the initial user interface.

Abstract: Systems and methods for automatically controlling conditions of a process are disclosed. In one example, a controller is programmed with a sequence of steps and parameters required to carry out a bioreactor process. The controller receives information related to a condition of the process over a first communication network, determines a control signal based on the received information and the programmed process, and sends the control signal over a second communication network to a benchtop utility tower. In one example, the utility tower can include transmitters for temperature, pH, and dissolved oxygen that send information related to a condition of the process to the controller over the first communication network, and an agitation system, a gas control system, a temperature control system and a pump control system that perform a control action based on the control signal affecting the process condition.

Abstract: An operating system architecture is based on a service model in which active entities (services) are containers for objects having a number of interfaces specified through a contract language that is a subset of the language in which the service is coded. Services may reside in the same address space or may reside in separate address spaces, without changing the programming model or compiled binaries. The location of a service is independent of the location of the service's clients and of services the service calls.

Abstract: A system and process for ensuring the smooth flow of electronic ink is described. Dynamic rendering is give priority over other event handlers. Priority may be the use of one or more queues to order when events occur and may be performing dynamic rendering prior to other steps.

Abstract: A method and system for creating a dynamic client side service proxy framework using meta-data and introspection capabilities of Open Grid Services Architecture (OGSA) service data is disclosed. The system and method include defining an Open Grid Service Invocation Factory configured to create a service proxy and introspecting an Open Grid Service Infrastructure (OGSI) service based on information exposed by the service. An OGSI Service Invocation Proxy is created defining a set of dynamic interfaces based on service introspection and a meta-data inspection interface of the Service Invocation Proxy. The Service Invocation Proxy exposes both static port type interfaces and dynamic interfaces to support more flexibility of the client.

Abstract: A system and method for binding software objects to the program code that implements them in accordance with run-time object typing that is independent of the program code typing system. Persistently-stored, run-time object instances (“persistent objects”) are maintained by a software-based system across transactions, user sessions, and application executions, and are identified by unique, typed names. Dynamic binding is provided through software constructs that are associated with corresponding persistent objects, and referred to as “Associators”. Associators provide links between object types and the program code that implements them.

Abstract: A system and method for providing composite applications for software-based systems that uses a built-in application model having at least one general purpose object type, and providing dynamic late-binding of object implementations through an object typing system decoupled from pre-run time program code, using persistently stored objects. The application model may require that program objects in a conformant application be instances of a predefined active object type, or optionally instances of a predefined reactive object type. The application model enables integration of applications into composite applications, and further integration of composite applications into subsequently defined systems. The run-time object typing system for persistently stored objects is independent of the class typing system that is defined at compile-time or link-time, and enables convenient and practical modifications during development, deployment and maintenance of composite applications.

Abstract: An interface module between a communication module and a number of instances of business logic modules of a software engine comprises first and second functional elements. The first functional element receives incoming data from the communications module and selects which of the instances of business logic modules to forward the incoming data based upon a rule set held within a data structure at the first functional element. The incoming data passes to the selected logic module instance via the second functional element. The second functional element determines either a single shot or a multiple shot mode of operation. If a multiple shot mode of operation is selected incoming data passes to the selected logic module instance sequentially. Alternatively, if a single shot mode of operation is selected a summary data record corresponding summary of incoming data received at the first function element passes to the selected logic module instance.

Abstract: A software method for obtaining an address of a thread-local variable while executing a computer program is described. The method designates a memory location to store an address of a function. The method, after the computer program starts to run, obtains the address of the thread-local variable by executing a resolver function whose address is stored in the memory location when a module that references the thread-local variable is loaded. The resolver can be a lazy resolver function or other resolver functions optimized for specific modules or variables.

Abstract: A dynamic nature is added to configuration files so that various types of dynamic functions can be performed within them. Variables are utilized within the configuration files. Thus, it is possible to have parameters specified in one configuration file and a formula to which the parameters will be applied in another configuration file. This allows changing of the values in the parameter file without having to modify the formula file, thereby streamlining the modification process when changes need to be made. In addition, it provides the capability for cross-referencing between configuration properties by allowing for variables in properties that refer to other properties.

Abstract: The present invention is directed to a loadable virtual memory manager, and generally to a computer operating system capable of supporting application programs running in a computer having a working memory, the computer operating system including a kernel resident in the working memory at run time, and a loadable virtual memory manager resident at link time outside of the working memory and dynamically loadable into the working memory at run time upon demand of one of the application programs. The kernel includes a loader for loading the virtual memory manager into the working memory in response to a demand from one of the application programs. The computer is able to access a storage memory separate from the working memory, the loadable virtual memory manager residing at link time in the storage memory. The loader loads the virtual memory manager from the storage memory to the working memory.

Abstract: A method and apparatus are provided for communicating information and carrying out other interactions between a browser and an application program. A hyperaction protocol is defined that enables a browser to directly call functions of an application program executed by a separate server over a public network. In one embodiment, in the course of parsing and displaying an HTML document or other HTML source text, a browser encounters or receives a hyperaction request of the form “hyperaction://<ApplicationAction>#<Payload>.” In response, the browser identifies a function or other action of a separate application. The browser calls that function of the application over the network and provides the payload. When a response is received, the browser extracts data values or function results provided by the application. As a result, a browser can directly interact with an application without using scripts or other awkward mechanisms of existing protocols.

Abstract: Methods and apparatus, including computer program products, for implementing extensions for computer program applications. A program according to one aspect of the invention has instructions to receive an application call to an extension method defined in an extension object definition, the extension object definition having associated extension object implementations, the extension object implementations providing extension method implementations of the extension method; instructions operable to obtain results by calling multiple extension method implementations of the extension method; and instructions operable to respond to the application call using the results obtained from the extension method implementations. A method according to another aspect includes the steps of deploying multiple extension method implementations for an extension method; and executing the multiple extension method implementations to determine the results of calling the extension method.

Abstract: Techniques for cloning programming code are disclosed. In an embodiment, the cloned code is in the form of functions in the C language. Further, in a method embodiment, a clone of a function is invoked, and information mapping the clone to the function is generated. At link time, if no function body of the clone is accessible by a linker, then the linker uses information mapping the clone to the function to satisfy a linker's requirement. At load time, if no function body of the clone is accessible by a loader, then the loader, based on the mapping information, allows selection of a body of the function. However, if the body function of the clone is accessible by the loader, then the loader allows selection of the body of the clone.

Abstract: The present invention is generally directed to a method, system, and article of manufacture that ensures the integrity of programs having variable portions. One aspect of this invention is a method for protecting software products having variant portions. This method includes identifying a reference to an external target in a software product, creating an identifier for the external target, and adding the identifier to the reference. In some embodiments, the unique identifier is a digital signature and the reference to an external target is a call to an external library.

Abstract: A runtime environment injects an instance of an external resource into an application component to be executed in the runtime environment by first determining an external resource associated with the application component, then selecting from a library of injectors an injector to inject an instance of the application component with an instance of an external resource referenced by the external resource annotation. The selected injector determines the instance of the application component to inject with the instance of the external resource and injects the instance of the application component with the instance of the external resource.

Abstract: Add-on functions to a software application are made through a single dynamic linked library (‘DLL’). After discovering, authenticating, and loading the DLL, the application may inspect the DLL to determine if it contains a function of a predetermined type. If the type is discovered, an object of the type may be instantiated and called. The inspection may evaluate metadata within the DLL to determine the precise characteristics of the function and compare the function to a predetermined type. Based on the authentication as well as the internal inspection of the DLL, extensions to existing software applications may be easily distributed and readily installed in an atomic fashion.

Abstract: An apparatus, system, and method are disclosed for supporting service components written in non-native runtime code in a Service Component Architecture (“SCA”). A read module is included to read an implementation type definition having metadata identifying executable code that executes a new implementation type. A receive module is included to detect a dynamic service call to a service component having the new implementation type. The dynamic service call is defined in an SCA message from a calling SCA component. A passing module is included to pass the dynamic service call to a predefined SCA implementation handler associated with the new implementation type. The SCA implementation handler includes native runtime code and implementation logic for executing the dynamic service call by executing non-native runtime code that returns a result to the SCA implementation handler. A packaging module packages the result in an SCA return message to the calling SCA component.

Abstract: A method of dynamic linkage including: receiving a request to launch a program; checking a system memory for the program; reserving a unique memory block of the system memory for the program and loading the program into the unique memory block if the program is not found in the memory of the system; performing internal memory relocations for the program if the program is not found in the memory of the system; ensuring that a library required by the program has been loaded into the system memory if the program is not found in the memory of the system; and invoking the program.

Abstract: A control is bound to a data item that provides a data binding context. Controls inside the template of a data bound control have properties which are bound to fields of the data item via a bidirectional data binding process. Bidirectional data binding allows a page developer to specify that a field in a data item is inserted into a control property value when a page is rendered on a client. Bidirectional data binding also allows the data-bound control to automatically and codelessly extract an arbitrary control property value associated with a data item field in a template when the page is posted back to the server.

Abstract: A system providing methodology for securing interfaces of executable files is described. In one embodiment, for example, a method is described for securing a program comprised of a plurality of interoperable components, the method comprises steps of: extracting information about a function of a first component of the program that is callable by at least one other component of the program; securing the extracted information; in response to an attempt by a second component of the program to invoke the function of the first component, validating authenticity of the second component; and if the second component is validated, providing access to the function of the first component using the secured extracted information.

Abstract: An embodiment generally relates to a method of increasing efficiency in a dynamic linker. The method includes determining a length of a source string and a check segment of the source string and selecting a candidate string from a plurality of strings. The method also includes determining a candidate check segment of the candidate string based on the length of the source string and verifying the source string and the candidate string are identical in response to the check segment of the source string being identical to candidate check segment.

Abstract: A method for compiling a logic design includes inputting a logic design and an input file into a plurality of compilers, respectively, where the logic design comprises a plurality of modules, compiling separately the plurality of modules into a plurality of object files, and linking the plurality of object files to execute the logic design.

Abstract: Methods, systems, and computer program products are disclosed for dynamically integrating software resources (such as web services and other back-end software resources) using the services of a content framework (such as a portal platform). A portlet model is leveraged to allow programmatic portlets to serve as proxies for web services, thereby extending portlets beyond their traditional visual role. A deployment interface and a system interface are described for these portlet proxies. The deployment interface is used for composing new web services, and a composition tool is described. The system interface allows for run-time management of the web services by the portal platform. The service provider for a particular function may be bound to the portlet proxy at development time or at run-time.

Abstract: Systems and methods for providing a universal print assist in a printer environment. A print assist is provided as a separate component from a print processor and spooler to enable a selective intercept and performance of an action (e.g., to modify, split, merge, redirect, gather or register information or otherwise alter or make observation of a print data stream) on the print data stream as the data stream is despooled by the spooler or print processor to a print provider without customizing any pre-existing components. The print assist uses a method whereby the print assist is bound to the output interface between the spooler and/or print processor and the print provider. Accordingly, the despooled print data stream passes through the print assist as it is despooled from the spooler or the print processor to the print provider. And, since the print assist is a separate component, the print assist may be used with any customized print processor and/or spooler to provide a universal print assist solution.

Abstract: It is checked, by referring to a deployment descriptor and type information of a component, whether the calling convention to be used by a caller component is the same as the calling convention to be used by a callee component, and if different, a class and an object of a proxy for performing a calling convention transformation process is generated.

Abstract: The invention relates to a system and a method for modelling and executing business processes in MES systems (manufacturing execution systems) or manufacturing control systems by means of a plurality of independently operating processes which are modelled by automatic state or execution machines and interconnected asynchronous connections. Said processes can be independently distributed to a plurality of computers (deployment) and communicate with each other in an asynchronous manner. The modelling of said automatic execution machines is carried out by means of activity and data flow diagrams according to UML representation. An advantage of the inventive system or method is that said processes can be immediately executed and tested. External software systems can be integrated by means of wrappers or adapters.

Abstract: Methods, systems, and computer program products for generating application processes by linking applications are provided. According to one method, identifiers for each of first and second applications may be received via a GUI. Further, output data for the first application may be determined from an application descriptor associated with the first application. Input data for the second application may be determined from an application descriptor associated with the second application. The output and input data may be displayed via the GUI. Input indicating linking of the output data for the first application to the input data for the second application may be received via the GUI. A loadable instance to invoke the first application to generate a value for the output data and to invoke the second application with the generated value as the input data may be created.

Abstract: A program start-up unit is provided which is capable of starting up a program at high speed and reducing the consumption of a memory. This program start-up unit analyzes the link relation between an application program and a shared library in the whole system, specifies a combination in which the management structure of a load state can be used in common to the utmost among application programs, and uses this management structure as a reference in the whole system.

Abstract: Historically, resources (e.g., dynamic link libraries) were organized based on factors including the expertise of development teams. Unfortunately, this creates shared resources of much greater functionality than required by any one client application. By reformulating shared resources according to nodes reachable by classified applications, reformulated resources reduce the over-inclusive nature of shared resources formed based on the expertise of development teams. Further, layering resources for lower order classified applications also reduces memory requirements.

Abstract: A present invention emulation internal representation revision method performs revisions on internal representations. In one embodiment of the present invention, an indication of a revision to loaded emulation code is received. Conditions for maintaining consistency are created. An ordered listing for providing an index correspondence to the emulation code is revised. The information from the listing is incorporated in the internal representation of the emulation code, such that a virtual machine implementing the loaded emulation code is not shut down.

Abstract: A solution for managing a set of artifacts for a runtime environment is provided, which enables improved tooling that supports runtime extensions to a runtime environment. In one embodiment, an extension handler is obtained for a runtime extension to the runtime environment. The runtime extension comprises a program code that can be included in the runtime environment to extend the default capabilities of a runtime engine/framework. The extension handler provides tooling support for extension artifacts that use/require the runtime extension. When a tooling request for an extension artifact is obtained, the tooling request is processed using the extension handler. In this manner, a tooling solution is shielded from needing to know the specifics of the extension artifact or corresponding runtime extension. Similarly, the developer of the extension handler for the runtime extension is shielded from needing to know any specifics of the tooling environment.

Abstract: Software loading is effected by means of a header 40 and software modules STUB1, STUB2 etc. The header 40 calls each stub in appropriate order, installing the stub in a loader region 42, executing the stub and then removing it. The STUBS may be encrypted and may be installed at random or pseudo-random locations in the region 42. Generic breaches of security, such as “riding the loader” are prevented because the stubs appear only transiently and at unpredictable positions. Security may be further improved by selecting each stub from a group of alternatives which are differently coded but functionally equivalent.

Abstract: Token-based object description is disclosed. In one embodiment, a system includes a plurality of objects and a set of tokens. Each object has at least one attribute, such as a type. Each token is mapped to a unique attribute. Each object is describable utilizing the set of tokens.

Abstract: An infrastructure that allows applications to run with specified versions of dependent assemblies, wherein 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 provides a manifest to specify any desired assembly versions on which it is dependent. Similarly, each assembly may have an assembly manifest that specifies the versions of assemblies on which it is dependent. During an initialization phase, an activation context is created for the application, based on the manifests, to map version independent names to a particular assembly version maintained on the system. While the application is in a running phase, for any globally named object that the application wants created, the activation context is accessed to locate the application's or assembly's manifest-specified version. The manifests and activation context constructed therefrom thus isolate an application from assembly version changes.

Abstract: The present invention provides a system and method for regulating access to a computer platform via a provably trustworthy trust level generator and monitor. The present invention comprises an operating system component that recognizes when applications desire access to a distributed platform. The operating system component is responsible for regulating access to the platform. Such regulation may be achieved by, for example, refusing to load the application or by limiting calls that an application can make through one or more Application Programming Interfaces. The present invention further comprises a distributed platform analysis component for analyzing applications attempting to access a distributed platform and for establishing a trust level for the application.

Abstract: A device driver module for supporting the use of an external device by a computing device which executes an operating system, the device driver module including an initialization portion which is called by the operating system, whereupon the initialization portion detects the presence of a driver plug-in module, obtains information from the detected driver plug-in module, and passes the information from the detected driver plug-in module to the operating system, and also including an operation portion which accesses and executes a functional portion of the detected plug-in module, receives from the operating system an event notification corresponding to the external device and, in the case that the detected driver plug-in module accepts the event notification, passes the event notification to the detected driver plug-in module.

Abstract: A method, system, and apparatus for implementing object interfaces at runtime are provided. According to the method, a request is received for a resource that includes a client side object that supports an object interface. In response to the request, program code is generated that implements the interface. Once the program code implementing the object interface has been generated, the requested resource and the program code implementing the object interface are returned in response to the request for the resource. An intermediary object for mediating communication between objects is also generated and returned in response to the request. If the object interface implements an interface for consuming data, the object interface registers itself with the intermediary object as an event consumer. If the object interface implements a provider interface, the object interface calls the intermediary object in response to the occurrence of a specified type of event.

Abstract: A present invention emulation class revision process performs emulation class revisions. In one embodiment of the present invention an indication of an emulation class revision initiation is received. A safe state for performing the emulation class revision is established. In one exemplary implementation the safe state retains prior processing results. An emulation class revision is performed.

Abstract: Techniques for selectively restarting processes based on API changes are provided. Information is stored that can be accessed to identify processes that are affected by an API change. The stored information can be modified to reflect the API change and the processes that are affected can be restarted. Thus, processes that are not affected by the API change need not be restarted.

Abstract: A method for increasing performance of selected poll applications without recompilation. In one embodiment, the method is comprised of assigning the name of a library as a value for an environment variable in a software application. The library is comprised of software code for emulating a system call. The method is further comprised of launching the software application. The launching causes invocation of a loader associated with the software application. The method is further comprised of preloading the library into the software application. The preloading performed by the loader. The method is further comprised of redirecting the software application to invoke an alternative mechanism when the software application requests a system call. The invocation of the alternative mechanism implements the library as the system call.

Abstract: Support is provided for multiple late binding objects with a same identifier, in an operating environment that only supports registration of a single late binding object with the same identifier. Each of a plurality of processes is associated with one of a plurality of late binding objects, such that at least two processes are each associated with a separate late binding object having the same identifier. Responsive to one of the plurality of processes attempting to access a late binding object by its identifier, a determination is made as to which late binding object is associated with the process. The associated late binding object is made available to the process.

Abstract: An application can be dynamically composed and maintained by creating the application within a component framework. The component framework includes components that each implement an integration interface. The integration interface has a number of methods that allow the component framework to manage the lifetime of the component, and which give the component the ability to communicate with the component framework, other components, and external entities.

Abstract: The present invention discloses a technique for processing input objects to generate output objects. Initially, an input object is received. The received input object contains input data and one input function. A type of the received input object is determined. Based on the determined type, it is ascertained whether the received input object satisfies one or more predefined requirements. When it is ascertained that the input object satisfies each predefined requirement, the input function is executed.

Abstract: An on-vehicle multimedia device to be operated by software 16 including an application module group 18 having a plurality of application modules 19 that realizes their respective different functions and an application control module 17 for controlling each of the application modules 19, characterized by the device comprising external hardware which inputs and outputs data to be processed by the software.