| Patent application number | Description | Published |
|---|
| 20080256512 | OUT OF BAND DATA AUGMENTATION - Systems and methods facilitate data augmentation in a computer environment. Data collections of various forms are altered out of band with at least one augmentor specifying alterations thereto. The alterations are applied to an associated collection of data such as programmatic code. In this manner, data can be modified, extended and/or removed from the collection to enable specialization and/or personalization, among other things. | 10-16-2008 |
| 20080282260 | DYNAMIC DISPATCH FOR CLASSES AND INTERFACES - Dynamic dispatch for classes and interfaces is encapsulated in a class-less scripting language. A plurality of mechanisms are employed to facilitate dynamic polymorphism. One or more target language constructs such as dictionary objects, prototype objects and/or derived types are utilized to capture class and interface method implementations. These constructs are subsequently referenced at runtime to invoke appropriate code. | 11-13-2008 |
| 20080295070 | NATIVE ACCESS TO FOREIGN CODE ENVIRONMENT - Mechanisms afford access to a foreign code environment from a native computer programming language. A program includes an attribute or declarative tag identifying foreign code associated with a native program construct. The attribute is subsequently morphed into script code that matches the calling convention and/or semantics of a related native construct. | 11-27-2008 |
| 20090024986 | RUNTIME CODE MODIFICATION - Source languages are translated to target dynamic programming languages. Runtime functionality including reflection and/or dynamic code modification exposed by a source language is mapped to a dynamic language implementation such as that of a script language. Target language dynamism is leveraged to efficiently support runtime functionality in a source language that is more static, for example. | 01-22-2009 |
| 20090049421 | AUTOMATIC AND TRANSPARENT MEMOIZATION - Functions are memoized automatically and transparently. Memoized code can be injected automatically within a program to facilitate efficient and/or expeditious execution thereof, among other things. The memoized code can intercept calls to an original function and return values in accordance with the code. Accordingly, callers of the function need not do anything special and can invoke the function without knowledge of it being memoized. | 02-19-2009 |
| 20090112975 | PRE-FETCHING IN DISTRIBUTED COMPUTING ENVIRONMENTS - Client-side performance is optimized through server-side pushing of content. Portions of content are requested and retrieved as required by a client-side application. Moreover, content likely to be needed in the near future is pre-fetched and pushed to the client. This is beneficial from an overhead standpoint since all content need not be provided to the client at once. Rather, content provisioning is throttled based on need, and wait time is mitigated by pre-fetching. | 04-30-2009 |
| 20090125919 | On-demand loading of types of software code of a program executing on a computing device - A first computing device receives (over a network) from at least a second computing device a container that includes information relating to types of software code that are potentially invoked by a program executing on the first computing device. A determination is made according to an on-demand basis, during execution of the program, whether a particular type of software code is to be loaded from the at least second computing device to the first computing device. | 05-14-2009 |
| 20090132998 | DEBUGGING MULTI-EXECUTION ENVIRONMENT APPLICATIONS - A framework is provided that allows for debugging of applications/systems that execute in multiple execution environments. Instead of using the native application programming interface to interact with an execution environment, an alternative implementation of at least some of the application programming interface of the native execution environment is employed to facilitate debugging in a disparate execution environment. | 05-21-2009 |
| 20090150422 | REPRESENTING POINTERS AND BOXING IN ENVIRONMENTS USING ONLY REFERENCE TYPES - An arrangement by which pointers may be represented in a restricted software execution environment that provides access to only reference types but not pointers is realized by modeling both pointers and value type boxing using a set of boxes (i.e., containers) which describe how to retrieve the value associated with the pointer, and emitting code for accessing the set of boxes. A decompiling and recompiling process is utilized in which code arranged to run in an execution environment that supports pointers is scanned to reveal pointer and boxing usage. In one illustrative example, code is responsively emitted to create one or more specific boxes. At runtime in the restricted execution environment, an instance of a box class is created to thus emulate a pointer to the value. | 06-11-2009 |
| 20090199159 | DECLARATIVE EXECUTION CONTEXT SPLITTING - Various technologies and techniques are disclosed for enabling code to be executed on one or more execution contexts based upon declarative annotations contained in the code or other locations. An annotation associated with a region of code is located. The annotation specifies information about an execution context where the region of code should be executed. A caller proxy is generated that is responsible for calling a callee adapter to execute the region of code. The callee adapter is generated that is responsible for receiving a call from the caller proxy and for dispatching a call to the region of code at the execution context. At runtime, the caller proxy receives a request to call the region of code and sends an execution request to the callee adapter. The callee adapter receives the execution request and dispatches a call to an executable version of the region of code. | 08-06-2009 |
| 20090235282 | APPLICATION REMOTE CONTROL - Application remote control is affected across execution contexts. In one instance, input can be acquired from controlled applications and employed by other applications. Additionally or alternatively, remote control can be employed to test applications while minimizing unintended changes to applications under test caused by observation. | 09-17-2009 |
| 20090249282 | CROSS PLATFORM COMPOSITIONAL WIDGETS - Mechanisms are afforded for supporting cross platform widgets. A generic widget can be converted into a specialized widget of a corresponding platform. Dually, a specialized widget can be generalized to a generic widget for subsequent deployment on the same or different host. Furthermore, support is provided for compositional widgets across platforms. | 10-01-2009 |
| 20090249489 | SECURITY BY CONSTRUCTION FOR WEB APPLICATIONS - Secure distributed Web applications are produced by default upon construction. Mechanisms are provided to address distributed application vulnerabilities (e.g., cross-site scripting, cross-site request forgery, replay attacks . . . automatically. These mechanisms are provided in conjunction with a tier-splitting component that breaks up an application for execution across multiple contexts or tiers. As a result, any application that is tier split is protected from security vulnerabilities by default without any intervention on the part of a developer. | 10-01-2009 |
| 20090265719 | APPLICATION MACRO RECORDING UTILIZING METHOD INTERCEPTION - Method interception is utilized to generate macros. A recorder is injected within application code. The recorder intercepts a call to a method, captures information, and calls the original method. A macro can be generated subsequently as a function of the captured information. In one instance, macros can be utilized to test the application code. Additionally, information capture and ultimately macro generation can be combined with a tier splitting mechanism. | 10-22-2009 |
| 20090276795 | VIRTUAL AUTOMATA - Computer-based machines can be modeled after a virtual automaton. The virtual automaton defines processes that are not bound statically to particular behavior but rather perform a lookup at runtime to bind behavior to a specific process mechanism. In accordance with one aspect, binding can be dependent upon runtime context information such as object type. Instances of virtual automaton are provided in the context of graph processing including serialization of object graphs and scanning/parsing, among others. | 11-05-2009 |
| 20100106767 | AUTOMATICALLY SECURING DISTRIBUTED APPLICATIONS - A processing system for distributed multi-tier applications is provided. The system includes a server component that executes a replica of a client-side application, where a client component executes the client-side application. The client component captures events from the client-side application and transmits the events to the replica to validate the computational integrity security of the application. | 04-29-2010 |
| 20100131556 | UNIFIED EVENT PROGRAMMING AND QUERIES - Event processing is transformed into query processing. Furthermore, asynchronous computation can be modeled as an event processing. Moreover, any computation that is or can be represented as push-based can be unified under an event-based processing approach subject to processing with query operators. Query processing can be performed with respect to one or more streams of events, wherein events identify a response to a raised value, among other things. | 05-27-2010 |
| 20100131743 | LAZY AND STATELESS EVENTS - Event-based processing is employed in conjunction with lazy and stateless events. Addition of any handlers is deferred until a user-specified handler is identified. Furthermore, event handlers can be composed at this time including the same properties as underlying events. More specifically, handlers specified on composite events can be composed and propagated up to a one or more related source events. As a result, handlers are not accumulated on composite events thereby making them stateless while allowing equivalent functionality upon invocation of the composed top-level handler. | 05-27-2010 |
| 20100131745 | EXCEPTIONAL EVENTS - An event-driven system enables handlers to be specified for success and failure, among other things. In other words, events can be explicitly encoded with an option of returning either a success or a failure result. In this manner, asynchronous programming and events can be unified. Multiple event streams can be employed to represent success and/or exceptional values. Alternatively, a disjoint union of regular and exceptional values can be employed with respect to a single event stream. | 05-27-2010 |
| 20100131921 | EXPOSING ASYNCHRONOUS MECHANISMS AS FIRST-CLASS EVENTS - Conversions can be applied to various asynchronous and/or concurrent mechanisms. In particular, such mechanism can be transformed into first-class events to facilitate processing with respect to first-class events including but not limited to querying. Both conventional events and asynchronous computations can be transformed to these events, for example by generating and linking a proxy event thereto. | 05-27-2010 |
