82 results about "Late binding" patented technology

A system for verifying intent in a card not present transaction is provided. The system includes a late binding token that is distributable to consumers without necessarily being bound to an account. The system also includes a client software that locates a token server configured to facilitate managing and communicating with the late binding token. The system also includes a protocol concerning how to build a verifiably secure structured proposal that carries an offer to the consumer through the client software.

A method, system and program product for more effectively managing the operational complexity of computerized data processing systems using an aspect oriented technique of binding a workflow engine to a data model representing the real environment is provided. The late binding aspect of the workflow provides more effective resource selection and allows for linking to differing workflows in accordance with the data model. Further results provided by the completed workflow may also be used to augment the data model thereby assuring a more current and consistent representation is found in the data model. A synchronization aspect if provided by the workflow result being used to then synchronize the data model with the physical resources manipulated by the workflow.

Described herein are improved systems, methods, and devices for delivering and managing metadata in a distributed computing platform such as a content delivery network (CDN) so as to configure content servers to handle client requests. The teachings hereof provide, among other things, scalable and configurable solutions for delivering and managing metadata, preferably by leveraging dynamically obtained control information. For example, in one embodiment, a given content server may store metadata, e.g., in a configuration file, that references dynamic, late-bound control information for use in satisfying dependencies. This dynamic control information can be requested by the CDN content server, typically from a remote host, when needed to parse and execute the metadata.

A semantic note taking system and method for collecting information, enriching the information, and binding the information to services is provided. User-created notes are enriched with labels, context traits, and relevant data to minimize friction in the note-taking process. In other words, the present invention is directed to collecting unscripted data, adding more meaning and use out of the data, and binding the data to services. Mutable and late-binding to services is also provided to allow private thoughts to be published to a myriad of different applications and services in a manner compatible with how thoughts are processed in the brain. User interfaces and semantic skins are also provided to derive meaning out of notes without requiring a great deal of user input. Linking physical objects to notes are also provided, such as through QR codes.

Described herein are improved systems, methods, and devices for delivering and managing metadata in a distributed computing platform such as a content delivery network (CDN) so as to configure content servers to handle client requests. The teachings hereof provide, among other things, scalable and configurable solutions for delivering and managing metadata, preferably by leveraging dynamically obtained control information. For example, in one embodiment, a given content server may store metadata, e.g., in a configuration file, that references dynamic, late-bound control information for use in satisfying dependencies. This dynamic control information can be requested by the CDN content server, typically from a remote host, when needed to parse and execute the metadata.

Described herein are improved systems, methods, and devices for delivering and managing metadata in a distributed computing platform such as a content delivery network (CDN) so as to configure content servers to handle client requests. The teachings hereof provide, among other things, scalable and configurable solutions for delivering and managing metadata, preferably by leveraging dynamically obtained control information. For example, in one embodiment, a given content server may store metadata, e.g., in a configuration file, that references dynamic, late-bound control information for use in satisfying dependencies. This dynamic control information can be requested by the CDN content server, typically from a remote host, when needed to parse and execute the metadata.

A compiler automatically generates a late binding interface implementation based upon programming language code and definition information. The programming language code is for implementing the late bound methods of the interface, while the definition information defines late binding interface features of the interface. The late binding interface implementation includes code for invoking one or more late bound methods through a late binding mechanism, and also can include code for directly invoking the one or more late bound methods through an early binding mechanism. The compiler can also generate client-side code for calling a late bound method of a late binding interface.

A system and method are provided for dynamically adjusting advertisement (“ad”) time for a multicast channel. In one embodiment, a variable ad insertion function operates to receive one or more multicasts of media content from a core distribution network, insert ad timeslots into the media content, and optionally perform late-binding of ads to the ad timeslots. The media content including the inserted ad timeslots and late-binded ads, if any, is then multicast to associated client devices over a feeder network using corresponding multicast channels. For each multicast channel, insertion of ad timeslots into the associated media content is dynamically controlled based on the number of users currently consuming or predicted to consume the multicast channel, the number of client devices receiving or predicted to receive the multicast channel, or both.

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.

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.

A late-binding multi-client streamer utilizing Remote Direct Memory Access (RDMA) transfers to obtain video and advertisement content is provided. For each client device, the streamer receives a video content selection. In response, the streamer initiates an RDMA transfer of the video content or a segment of the video content from a storage device of a video content server to an associated video buffer and begins streaming the video content from the video buffer to the client device. When an upcoming advertisement slot in the video content is detected, the streamer initiates an RDMA transfer of an advertisement for the ad slot from a storage device associated with an advertisement content server to an associated ad buffer. The streamer then inserts the advertisement from the ad buffer into the ad slot in the video content as the video content is streamed to the client device.

A system providing late-binding of advertisements to video content and incorporating a push-caching scheme is disclosed. In general, the system includes an advertisement server located at a central location such as a central headend and a number of late-binding systems located at locations such as a number of remote headends. The late-binding systems are connected to the advertisement server via a Wide Area Network (WAN). Each of the late-binding systems is also connected to an associated advertisement cache via a Local Area Network (LAN). A cache assignment agent associated with the advertisement server operates to push advertisements to the advertisement caches associated with the late-binding systems in a predictive fashion based on, for example, historical information for the late-binding systems and/or profiles of users or viewers associated with the client devices served by the late-binding systems.

A method of optimizing the runtime performance of a program written in an interpreted programming language can include loading, within a virtual machine having a Just In Time (JIT) compiler, the program and a file specifying frequency of execution data for at least one component of the program. The program can be executed. The executing step can include reading the file specifying the frequency of execution data, seeding a counter of the virtual machine associated with the component(s) with a value derived from the frequency of execution data, and performing a JIT action upon the component(s) of the program according to the seeded counter of the virtual machine.

A method of producing an executable image from an object file without shared library support from the operating system, wherein the executable image requires a shared library file in order to resolve at least one of the symbols called for in the object file. A method of optimizing the loading of a previously linked file into working memory in a computer for executing in a single address space of the working memory, the file containing an instruction to make an indirect jump to a location in a shared library through an import section of the file. A w method for optimizing the loading of a previously linked file into working memory in a computer for executing in a single address space of the working memory, the file containing plural sections with number-filled padding between the end of each section and a succeeding page boundary. A method of optimizing the loading of a previously linked file into working memory in a computer for executing in a memory sharable with other executables. This method includes selecting a portion of code in the previously linked file, removing the portion of code from the previously linked file, and constructing a dynamically linked library file containing the portion of the code, the dynamically linked library file being available to plural files including the previously linked file. A method of converting an image which has been previously linked for executing in an unshared memory into an image optimized for use with virtual memory.

Late-binding/dynamic pathname resolution can be performed by a variable identifier operating in user or kernel mode, and a pathname engine and a data structure operating in kernel mode. The variable identifier identifies a variable in a pathname. The pathname engine evaluates the variable by converting the variable into a character string such that a path to an object file is established. The pathname engine determines a scope of potential character string values for the variable by mapping the variable to corresponding values stored in the data structure. Each variable has a well-defined scope of values because the only values available are the values selected for storage in the data structure. The mechanism for establishing values is extensible such that variable/value pairs can be implemented in the data structure at any time.

A development environment in which unit tests are prepared. The unit tests run in a host environment for more complete and accurate testing of program units. The development environment uses a test execution shim to access an adapter running in the host environment. The host adapter may invoke other program objects that run specific tests. Such objects may late bind to the unit under test. An accessor class may facilitate late binding to the specific unit under test while allowing tests authored in the development environment to use context sensitive information needed to access the unit under test.

A computer-implemented method for flexibly and efficiently representing and applying business rules in a transaction-processing relational database management system (RDBMS) environment. The method includes providing a deterministic rule-based expert-system shell. A late-binding mechanism within the RDBMS environment is also provided. An extensible data-maintenance mechanism is created for the rule-based expert-system shell. The extensible data-maintenance mechanism maintains sets of approval rules governing business transactions generated by other transaction-processing applications. The data-maintenance mechanism uses late binding to make the sets of rules and rule components stored in the data-maintenance mechanism arbitrarily extensible. A rule-processing engine applies the sets of approval rules stored in the extensible data-maintenance mechanism to business transactions originating in transaction-processing applications. The method provides for a plurality of approval-rule types, each making a qualitatively different contribution to the list of approvers required for any given business transaction. The method calculates the list of approvers required for a given business transaction by applying the appropriate set of approval rules to the transaction.

A Java/COM bridge provides enhanced late-bound COM-to-Java support. The Java/COM bridge allows a COM application to make a late bound call to a Java class in a Java application wherein the late bound call contains a parameter indicating that the Java class should not be instantiated. The Java/COM bridge returns to the COM application a static COM proxy representing the Java class without instantiating the Java class. Using the static COM proxy, the COM application can call static methods and reference static variables of the Java class. The COM application can also call constructors of the Java class that take parameters by passing the parameters without specifying a method. The Java/COM bridge will identify the Java class constructor based on the specified parameters and instantiate a Java object by calling the identified constructor with the specified parameters.

A method, computer program product, and data processing system for installing and registering software components as part of a unified solution, rather than simply as individual software components, are disclosed. According to a preferred embodiment, an installer supplies specific registration information as part of its overall installation process. This registration information overrides that used by the native component install technology to register the solution/component, as appropriate. In a preferred embodiment, the standard registration information provided by each software component's individual installer program is removed by an installation wrapper script and replaced by registration information that pertains to the installed solution as a whole. This registration scheme may just be characterized as a form of “late binding” of registration information.

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. The loadable virtual memory manager is removable from the working memory upon lack of demand therefor by the application programs.