Abstract: 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.

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: A queue can store streams of data acquired from servers asynchronously based upon received data requests and subsequent subscription with respect to one or more data sources/servers. The queue can be managed for subsequent synchronous or asynchronous release of received streams of data, for example.

Abstract: 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.

Abstract: A documentation system is described herein that automatically generates documentation for software code from tests that verify the correct operation of the software code. Software development teams often write automated tests (software that tests the software being shipped), such as unit tests. When written correctly, these tests are a written contract of what the software is supposed to do. The documentation system can use static and dynamic analysis in combination with annotations in the test code to extract the contract from these tests and leverage the extracted information to automatically generate the documentation. The system can then visually display this information in a textual or graphical way. Thus, the documentation system generates documentation that more accurately reflects how software code is expected to operate, without introducing significant burdens into the software development cycle.

Abstract: A fuzz testing system is described herein that represents event sources, channels, processors, and consumers as first-class entities in an application. Abstracting event-related entities allows fuzzing through injecting, dropping, reordering, and delaying events from within the application. This translates into the ability to localize the areas under test and perform fuzzing in a systematic manner. In some embodiments, the fuzz testing system tests concurrent asynchronous and event-based code, and can generate event streams based on a given statistical distribution. Representing events, event sources, processors, and sinks as first-class objects provides easy access to the event handlers and facilitates implementing fuzzing by introducing event processors between the source and the sink. Thus, the fuzz testing system improves the testability of applications and APIs with asynchronous behavior and provides a uniform framework for introducing fuzz testing into such applications.

Abstract: Program language support is provided to facilitate reactive programming. Code can be provided that initiates conversion between a first-class pattern and a second-class pattern, wherein the patterns operate with respect to push-based data. Support is also provided for producing and consuming push-based data in accordance with an iterator pattern, for example.

Abstract: Query operators such as those that perform grouping functionality can be implemented to execute lazily rather than eagerly. For instance, one or more groups can be created and/or populated lazily with one or more elements from a source sequence in response to a request for a group or element of a group. Furthermore, lazy execution can be optimized as a function of context surrounding a query, among other things.

Abstract: Monadic types are preserved for query operators to further query operator compositionality utilizing operators defined over a monad. Query operators that are defined over a monad and are suited to return non-monadic types are constructed or altered to return a monadic type. For instance, aggregate query operators defined over a local or remote sequence monad can be generated that return a monadic type.

Abstract: 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.

Abstract: 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.

Abstract: A workflow is designated for execution across a plurality of autonomous computational entities automatically. Among other things, the cost of computation is balanced with the cost of communication among computational entities to reduce total execution time of a workflow. In other words, a balance is struck between grouping tasks for execution on a single computational entity and segmenting tasks for execution across multiple computational entities.

Abstract: A state machine may be represented using event-driven objects in a database query language. A bind operator from a database query language may be used as a state transition function, where the transition function has side effects defining the state. The objects may be manipulated with event driven expressions and operators and perform what would otherwise be complex operations with simple state machines.

Abstract: A workflow is described and subsequently constructed by a general-purpose program. Among other things, such construction enables meta-programming to be employed. Further, workflow item and task dependencies can be explicitly expressed in the workflow and utilized to, among other things, optimize workflow execution for one or more factors. For instance, dependency information can be employed with respect to scheduling concurrent execution of tasks as well as to confine re-execution, upon workflow or item changes, to tasks affected by the changes. In addition, messages pertaining to workflow processing can be typed to facilitate logging in a structured and easily comprehensible manner.

Abstract: Dynamic dispatch for classes and interfaces is encapsulated in a class-less scripting language. A plurality of mechanisms is 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.

Abstract: A system and method for controlling the execution of notifications in a computer system with multiple notification contexts. A RunOn operator enables context hopping between notification contexts. Push-based stream operators optionally perform error checking to determine if notifications combined into a push-based stream share a common notification context. Context boxes group together notification creators and associate their notifications with a common scheduler and notification context. Operators employ a composition architecture, in which they receive one or more push-based streams and produce a transformed push-based stream that may be further operated upon. Components may be used in combinations to implement various policies, including a strict policy in which all notifications are scheduled in a common execution context, a permissive policy that provides programming flexibility, and a hybrid policy that combines flexibility with error checking.

Abstract: A library of operators is provided for performing operations on push-based streams. The library may be implemented in a computing device. The library may be stored on a tangible machine-readable medium and may include instructions to be executed by one or more processors of a computing device. The library of operators may include groups of operators for performing various types of operations regarding push-based streams. The groups of operators may include, but not be limited to, standard sequence operators, other sequence operators, time operators, push-based operators, asynchronous operators, exception operators, functional operators, context operators, and event-specific operators.

Abstract: 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.

Abstract: Upon accessing binary that was generated by a compiler using corresponding source code, a potential reportable problem in the binary is identified. The binary includes a compiler transformed indication that the potential reportable problem is to be suppressed at least under some circumstances. The transformed indication is generated by the compiler using a corresponding untransformed indication in the corresponding source code. The transformed indication is then used to decide that the potential reportable problem should not be reported. Thus, artifacts within the source code itself may ultimately direct what problems are not to be reported on when the corresponding binary is analyzed after the compile phase.

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.