Abstract:
An outer event stream can be modeled to represent duration for an event with an inner event stream. The inner event stream can be generated to represent duration of at least one event from the outer event stream. By modeling the outer event stream to include duration, coincidence between two or more events can be determined. More specifically, the modeling of the outer event stream enables use of operators to identify coincidence between events from event streams.
Abstract:
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.
Abstract:
An outer event stream can be modeled to represent duration for an event with an inner event stream. The inner event stream can be generated to represent duration of at least one event from the outer event stream. By modeling the outer event stream to include duration, coincidence between two or more events can be determined. More specifically, the modeling of the outer event stream enables use of operators to identify coincidence between events from event streams.
Abstract:
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.
Abstract:
Asynchronous methods and calls are produced automatically as a function of a declarative indication of intent. A method annotated with an asynchronous attribute or method call including a special asynchronous function can be identified. Subsequently, an asynchronous version of an identified synchronous method or call is generated automatically. Assistance is also provided for specifying intent.
Abstract:
The present invention extends to methods, systems, and computer program products for analyzing binary code. Binary code is received. Code analysis rules indicative of a query related to the functionality of the binary code are received. The query is implemented in analysis code configured to determine results of the query. It is determined if valid cached results for the query are cached in a results store. If not, the analysis code is invoked to determine the results for the query and the results are cached. Accordingly, when the query is received in the future, the results can be accessed from the results store without having to invoke the analysis code to determine the results. If so, the cached results are retrieved so as to avoid further invocation of the analysis code. The results are returned.
Abstract:
An outer event stream can be modeled to represent duration for an event with an inner event stream. The inner event stream can be generated to represent duration of at least one event from the outer event stream. By modeling the outer event stream to include duration, coincidence between two or more events can be determined. More specifically, the modeling of the outer event stream enables use of operators to identify coincidence between events from event streams.
Abstract:
Embodiments provided a formalized set of intermediate analysis contexts that are relevant for analysis checks of target code. Such intermediate analysis context may include, but are not limited to, the development phase of targeted code, the type or state of the targeted code, a source manipulating the targeted code, a purpose for the targeted code, or other development or runtime requirements. Accordingly, embodiments dynamically identify a current analysis context under which targeted code is being developed and can then execute rules based on knowledge of what contexts the rule(s) may apply. More specifically, analysis rules can describe (e.g., via metadata) those context conditions under which a rule can run. Based on such description and the current context, those rules that have been configured to apply to such context conditions can be executed.